def deriving_finite_difference_approximations(u, x, h, hs, order=1, errors=1): '''See also `1_2.py`. ''' # the method of undetermined coefficients length = len(hs) hs = sympy.Matrix([hs]) _hs = sympy.ones(1, length) A = sympy.ones(length) for ith in range(1, length): _hs = _hs.multiply_elementwise(hs) A[ith, :] = _hs b = sympy.zeros(length, 1) b[order] = sympy.factorial(order) coefficients = A.solve(b) # errors _errors = [None] * errors Du = u(x).diff(x, length-1) denominator = sympy.factorial(length-1) for ith in range(errors): denominator *= length + ith _hs = _hs.multiply_elementwise(hs) coefficient = coefficients.dot(_hs) / denominator Du = Du.diff() _errors[ith] = coefficient * h**(length+ith-order) * Du # finite difference approximations Du = sum(c*u(x+a*h) for c, a in zip(coefficients, hs)) return Du/h**order, sum(_errors)
def calculate_proba_assessment(assessment_rules): if (sym.ones(1, assessment_rules.shape[0]) * assessment_rules)[0, 0] == 4: proba_assessment = 1 elif (sym.ones(1, assessment_rules.shape[0]) * assessment_rules)[0, 0] == 3: proba_assessment = 1 - (proba_matrix_second_order * (sym.ones(4, 1) - assessment_rules))[0, 0] else: proba_assessment = (proba_matrix_second_order * assessment_rules)[0, 0] return (proba_assessment)
def main(): a=Symbol("a", real=True) b=Symbol("b", real=True) c=Symbol("c", real=True) p = (a,b,c) assert u(p, 1).D * u(p, 2) == Matrix(1, 1, [0]) assert u(p, 2).D * u(p, 1) == Matrix(1, 1, [0]) p1,p2,p3 =[Symbol(x, real=True) for x in ["p1","p2","p3"]] pp1,pp2,pp3 =[Symbol(x, real=True) for x in ["pp1","pp2","pp3"]] k1,k2,k3 =[Symbol(x, real=True) for x in ["k1","k2","k3"]] kp1,kp2,kp3 =[Symbol(x, real=True) for x in ["kp1","kp2","kp3"]] p = (p1,p2,p3) pp = (pp1,pp2,pp3) k = (k1,k2,k3) kp = (kp1,kp2,kp3) mu = Symbol("mu") e = (pslash(p)+m*ones(4))*(pslash(k)-m*ones(4)) f = pslash(p)+m*ones(4) g = pslash(p)-m*ones(4) #pprint(e) xprint( 'Tr(f*g)', Tr(f*g) ) #print Tr(pslash(p) * pslash(k)).expand() M0 = [ ( v(pp, 1).D * mgamma(mu) * u(p, 1) ) * ( u(k, 1).D * mgamma(mu,True) * \ v(kp, 1) ) for mu in range(4)] M = M0[0]+M0[1]+M0[2]+M0[3] M = M[0] assert isinstance(M, Basic) #print M #print simplify(M) d=Symbol("d", real=True) #d=E+m xprint('M', M) print "-"*40 M = ((M.subs(E,d-m)).expand() * d**2 ).expand() xprint('M2', 1/(E+m)**2 * M) print "-"*40 x,y= M.as_real_imag() xprint('Re(M)', x) xprint('Im(M)', y) e = x**2+y**2 xprint('abs(M)**2', e) print "-"*40 xprint('Expand(abs(M)**2)', e.expand())
def main(): a = Symbol("a", real=True) b = Symbol("b", real=True) c = Symbol("c", real=True) p = (a, b, c) assert u(p, 1).D * u(p, 2) == Matrix(1, 1, [0]) assert u(p, 2).D * u(p, 1) == Matrix(1, 1, [0]) p1, p2, p3 = [Symbol(x, real=True) for x in ["p1", "p2", "p3"]] pp1, pp2, pp3 = [Symbol(x, real=True) for x in ["pp1", "pp2", "pp3"]] k1, k2, k3 = [Symbol(x, real=True) for x in ["k1", "k2", "k3"]] kp1, kp2, kp3 = [Symbol(x, real=True) for x in ["kp1", "kp2", "kp3"]] p = (p1, p2, p3) pp = (pp1, pp2, pp3) k = (k1, k2, k3) kp = (kp1, kp2, kp3) mu = Symbol("mu") e = (pslash(p) + m * ones(4)) * (pslash(k) - m * ones(4)) f = pslash(p) + m * ones(4) g = pslash(p) - m * ones(4) xprint("Tr(f*g)", Tr(f * g)) M0 = [(v(pp, 1).D * mgamma(mu) * u(p, 1)) * (u(k, 1).D * mgamma(mu, True) * v(kp, 1)) for mu in range(4)] M = M0[0] + M0[1] + M0[2] + M0[3] M = M[0] if not isinstance(M, Basic): raise TypeError("Invalid type of variable") d = Symbol("d", real=True) # d=E+m xprint("M", M) print("-" * 40) M = ((M.subs(E, d - m)).expand() * d**2).expand() xprint("M2", 1 / (E + m)**2 * M) print("-" * 40) x, y = M.as_real_imag() xprint("Re(M)", x) xprint("Im(M)", y) e = x**2 + y**2 xprint("abs(M)**2", e) print("-" * 40) xprint("Expand(abs(M)**2)", e.expand())
def test_creation(): """ Check that matrix dimensions can be specified using any reasonable type (see issue 1515). """ raises(ValueError, 'zeros((3, 0))') raises(ValueError, 'zeros((1,2,3,4))') assert zeros(3L) == zeros(3) assert zeros(Integer(3)) == zeros(3) assert zeros(3.) == zeros(3) assert eye(3L) == eye(3) assert eye(Integer(3)) == eye(3) assert eye(3.) == eye(3) assert ones((3L, Integer(4))) == ones((3, 4))
def run(self): '''refactor code later''' y = Matrix(self.y) x = Matrix(self.x) beta_sym = symbols(f'beta0:{self.beta.shape[1]}') # BETA = tuple of length = 1 * p beta = Matrix(np.array(beta_sym)) loss_func = (y - (x * beta)) * ones(beta.shape[1], 1) loss_func = ones(1, loss_func.shape[0]) * square_matrix_element_wise(loss_func) / 400 # mean # loss_func = ones(1, loss_func.shape[0]) * square_matrix_element_wise(loss_func) # mean # loss_func = np.random.rand(1,1) penalty = self.lmda * (ones(1, beta.shape[0]) * square_matrix_element_wise(beta)) if self.l1 else 0 return loss_func + penalty
def test_creation_args(): """ Check that matrix dimensions can be specified using any reasonable type (see issue 1515). """ raises(ValueError, 'zeros((3, -1))') raises(ValueError, 'zeros((1, 2, 3, 4))') assert zeros(3L) == zeros(3) assert zeros(Integer(3)) == zeros(3) assert zeros(3.) == zeros(3) assert eye(3L) == eye(3) assert eye(Integer(3)) == eye(3) assert eye(3.) == eye(3) assert ones((3L, Integer(4))) == ones((3, 4)) raises(TypeError, 'Matrix(1, 2)')
def make_state_space_sym(num_signals, num_states, is_homo): mu_rho_dict_sym = {} state_state_sym_dict = {} mu_names = ['mu_'+str(i) for i in range(num_states)] rho_names = ['rho_'+str(i) for i in range(num_states)] mu_rho_names = mu_names + rho_names mu_names_sym = [sympy.Symbol(x) for x in mu_names] rho_names_sym = [sympy.Symbol(x) for x in rho_names] mu_rho_names_sym = [sympy.Symbol(x) for x in mu_rho_names] mu_rho_dict_sym.update(dict(zip(mu_rho_names, mu_rho_names_sym))) A_identity_sym = sympy.eye(num_states) A_rhoblock_sym = sympy.diag(*rho_names_sym) A_sym = sympy.diag(A_identity_sym, A_rhoblock_sym) D_sym_mu_part = sympy.ones(num_signals, num_states) D_sym_zeta_part = sympy.ones(num_signals, num_states) D_sym = D_sym_mu_part.row_join(D_sym_zeta_part) if is_homo: sigmas_signal_names = [ 'sigma_signal_'+str(i) for i in range(num_signals)] sigmas_state_names = ['sigma_state_'+str(i) for i in range(num_states)] sigmas_signal_sym = [sympy.Symbol(x) for x in sigmas_signal_names] sigmas_state_sym = [sympy.Symbol(x) for x in sigmas_state_names] C_nonsingularblock_sym = sympy.diag(*sigmas_state_sym) G_nonsingularblock_sym = sympy.diag(*sigmas_signal_sym) C_singularblock_sym = sympy.zeros(num_states, num_states) G_singularblock_sym = sympy.zeros(num_signals, num_states) G_sym = G_singularblock_sym.row_join(G_nonsingularblock_sym) C_sym = sympy.diag(C_singularblock_sym, C_nonsingularblock_sym) main_matrices_sym = { 'A_z': A_sym, 'C_z': C_sym, 'D_s': D_sym, 'G_s': G_sym} sub_matrices_sym = {'A_z_stable': A_rhoblock_sym, 'C_z_nonsingular': C_nonsingularblock_sym, 'G_s_nonsingular': G_nonsingularblock_sym} state_state_sym_dict.update(main_matrices_sym) state_state_sym_dict.update(sub_matrices_sym) return state_state_sym_dict
def hamilton(M): text = "Metoda Cayleya-Hamiltona<br>" eigen_values, eigen_vectors = eigen(M) text += 'Eigenvalues: $' + sp.latex(eigen_values) + ' = ' + sp.latex( eigen_values.evalf(5)) + '$<br>' eigen_values = eigen_values.evalf(5) x = sp.symbols( str(['a' + str(i) for i in range(len(eigen_values))])[1:-1].replace("'", "")) if len(eigen_values) == 1: x = [x] A = sp.ones(len(x), 1) for i in range(1, len(x)): A = sp.Matrix(sp.BlockMatrix([A, sp.HadamardPower(eigen_values, i)])) b = sp.Matrix(sp.HadamardPower(sp.E, eigen_values * t)) result = sp.Matrix(list(sp.linsolve((A, b), *x))[0]) text += "$"+sp.latex(b)+' = '+sp.latex(A)+'\\bullet'+sp.latex(sp.Matrix(x))+'\\implies' + \ sp.latex(sp.Matrix(x))+' = '+sp.latex(result) + "$<br>" s = sp.diag(*tuple([1] * len(x))) * result[0, 0] for i in range(1, len(x)): s += M * result[i, 0] text += "$e^{\\mathbb{A}t} = " + sp.latex(sp.simplify(s)) + "$<br><br>" return s, text
def steady_state(self, start_state=None): # Initialize the probabilities for transisions to the same state matrix = self._fill_in_diagonal_transistions(self.matrix) # Subtract the identity matrix matrix = matrix - self._eye(matrix.rows) # Add a row at the bottom of the matrix for the equation that all # variable probabilities must add up to 1 matrix = matrix.row_insert(matrix.rows, sympy.ones(1, matrix.cols)) # Add a column for the target values matrix = matrix.col_insert(matrix.cols, sympy.zeros(matrix.rows, 1)) matrix[matrix.rows-1, matrix.cols-1] = 1 symbols = [] for col in range(self._matrix_size(self.matrix)): symbols.append(sympy.Symbol("col_" + str(col))) solution = sympy.solve_linear_system(matrix, *symbols) result = {} for state in self.states: state_index = self.states[state] result[state] = solution[symbols[state_index]] return result
def compute(mu, lmbda, rad, length): import sympy as smp from sympy import Matrix import numpy as np Tr = lambda A: A[0, 0] + A[1, 1] + A[2, 2] Div = lambda A, b: Matrix(3, 3, lambda i, j: smp.diff(A[i,j], b[j], 1)) * smp.ones(A.shape[1], 1) l, m = 1.25, 1. Id = smp.eye(3) x, y, z = smp.symbols('x y z') u, v, w = [z*smp.exp(v/length) for v in [x, y, z]] grad_u = Matrix([u, v, w]).jacobian(Matrix([x, y, z])) F = smp.MatrixSymbol('F', 3, 3) C = F.T*F E = (C-Id)/2 W = 0.5*l*Tr(E)**2 + m*Tr(E*E) P = Matrix(3, 3, lambda i, j: smp.diff(W, F[i, j], 1)).subs(F, grad_u + Id) f = - Div(P, [x, y, z]) u, v, w = smp.lambdify([x, y, z], u), smp.lambdify([x, y, z], v), smp.lambdify([x, y, z], w) return smp.lambdify([x, y, z], P), \ smp.lambdify([x, y, z], f), \ (lambda x_, y_, z_: np.array([u(x_, y_, z_), v(x_, y_, z_), w(x_, y_, z_)]).reshape(3,))
def get_matrix_of_converted_atoms(Nu, positions, pending_conversion, natural_influence, Omicron, D): """ :param Nu: A matrix with a shape=(<number of Matters in Universe>, <number of Atoms in Universe>) where each Nu[i,j] stands for how many atoms of type j in matter of type i. :type Nu: Matrix :param ps: positions of matters :type ps: [Matrix] :return: """ x, y = symbols('x y') number_of_matters, number_of_atoms = Nu.shape M = zeros(0, number_of_atoms) if number_of_matters != len(positions): raise Exception("Parameters shapes mismatch.") for (i, position) in enumerate(positions): (a, b) = tuple(position) K = get_conversion_ratio_matrix(pending_conversion, Nu[i, :]) M = M.col_join(((diag(*(ones(1, number_of_atoms)*diag(*K)*Omicron.transpose()))*D).transpose() * natural_influence).transpose().subs({x: a, y: b})) return M.evalf()
def test_matrix_tensor_product(): l1 = zeros(4) for i in range(16): l1[i] = 2**i l2 = zeros(4) for i in range(16): l2[i] = i l3 = zeros(2) for i in range(4): l3[i] = i vec = Matrix([1,2,3]) #test for Matrix known 4x4 matricies numpyl1 = np.matrix(l1.tolist()) numpyl2 = np.matrix(l2.tolist()) numpy_product = np.kron(numpyl1,numpyl2) args = [l1, l2] sympy_product = matrix_tensor_product(*args) assert numpy_product.tolist() == sympy_product.tolist() numpy_product = np.kron(numpyl2,numpyl1) args = [l2, l1] sympy_product = matrix_tensor_product(*args) assert numpy_product.tolist() == sympy_product.tolist() #test for other known matrix of different dimensions numpyl2 = np.matrix(l3.tolist()) numpy_product = np.kron(numpyl1,numpyl2) args = [l1, l3] sympy_product = matrix_tensor_product(*args) assert numpy_product.tolist() == sympy_product.tolist() numpy_product = np.kron(numpyl2,numpyl1) args = [l3, l1] sympy_product = matrix_tensor_product(*args) assert numpy_product.tolist() == sympy_product.tolist() #test for non square matrix numpyl2 = np.matrix(vec.tolist()) numpy_product = np.kron(numpyl1,numpyl2) args = [l1, vec] sympy_product = matrix_tensor_product(*args) assert numpy_product.tolist() == sympy_product.tolist() numpy_product = np.kron(numpyl2,numpyl1) args = [vec, l1] sympy_product = matrix_tensor_product(*args) assert numpy_product.tolist() == sympy_product.tolist() #test for random matrix with random values that are floats random_matrix1 = np.random.rand(np.random.rand()*5+1,np.random.rand()*5+1) random_matrix2 = np.random.rand(np.random.rand()*5+1,np.random.rand()*5+1) numpy_product = np.kron(random_matrix1,random_matrix2) args = [Matrix(random_matrix1.tolist()),Matrix(random_matrix2.tolist())] sympy_product = matrix_tensor_product(*args) assert not (sympy_product - Matrix(numpy_product.tolist())).tolist() > \ (ones((sympy_product.rows,sympy_product.cols))*epsilon).tolist() #test for three matrix kronecker sympy_product = matrix_tensor_product(l1,vec,l2) numpy_product = np.kron(l1,np.kron(vec,l2)) assert numpy_product.tolist() == sympy_product.tolist()
def met_zeyd(A, b): C, d = iteration_view(A, b) H = sympy.zeros(3) F = sympy.zeros(3) c = sympy.zeros(3,1) for i in xrange(3): c[i] = d[i] for j in xrange(3): if i > j: H[i, j] = C[i, j] else: F[i, j] = C[i, j] print "\nx = Cx + d\n" print "C = \n", C, "\n", "\nd = \n", d print "\nConvergence: ", convergence_mzeyd(C, d) if convergence_mzeyd(C, d): E = sympy.eye(3) x0 = sympy.ones(3, 1) x1 = (E-H).inv()*F*x0 + (E-H).inv()*c while ((x1-x0)[0] > 0.00001 or (x1-x0)[1] > 0.00001 or\ (x1-x0)[2] > 0.00001 or (x0-x1)[0] > 0.00001 or\ (x0-x1)[1] > 0.00001 or (x0-x1)[2] > 0.00001): x0 = x1 x1 = (E-H).inv()*F*x0 + (E-H).inv()*c print "\nSolution:" return [element for element in x1]
def cholesky(A): """ # A is positive definite mxm """ assert A.shape[0] == A.shape[1] # assert all(A.eigenvals() > 0) m = A.shape[0] N = deepcopy(A) D = ones(*A.shape) for i in xrange(m - 1): for j in xrange(i + 1, m): N[j, i] = N[i, j] D[j, i] = D[i, j] n, d = ratior(N[i, j], D[i, j], N[i, i], D[i, i]) N[i, j], D[i, j] = n, d if verbose_chol: print "i={}, j={}".format(i + 1, j + 1) print "N:" printnp(N) print "D:" printnp(D) for k in xrange(i + 1, m): for l in xrange(k, m): n, d = multr(N[k, i], D[k, i], N[i, l], D[i, l]) N[k, l], D[k, l] = subr(N[k, l], D[k, l], n, d) if verbose_chol: print "k={}, l={}".format(k + 1, l + 1) print "N:" printnp(N) print "D:" printnp(D) return N, D
def recursive_com(link, frame): """ Recursive function to compute the center of mass Parameters ---------- link : links.Link Link from which you want to compute the center of mass. frame : links.link Frame in which you want to express the CoM Returns ------- com : sympy.matrices.dense.MutableDenseMatrix Jacobian matrix between origin and destination """ m = link.mass / self.mass hc = ones(4, 1) hc[:3, :] = link.com if link.is_root: T = eye(4, 4) else: T = self.forward_kinematics( f"link_{frame.link_id}", f"joint_" f"{link.child_joints[0]}") cm = m * (T @ hc) if link.is_terminal: return cm else: for child in link.parent_joints: cm += recursive_com( self.links[self.joints[child].child], frame) return cm
def relaxation_local(self, m, with_rel_velocity = False): if with_rel_velocity: eq = (self.Tu*self.eq).subs(list(zip(self.mv, m))) else: eq = self.eq.subs(list(zip(self.mv, m))) relax = (sp.ones(*self.s.shape) - self.s).multiply_elementwise(sp.Matrix(m)) + self.s.multiply_elementwise(eq) alltogether(relax) return Eq(m, relax)
def initialise_working_matrices(G): """ G is a nonzero matrix with at least two rows. """ B = eye(G.shape[0]) # Lower triang matrix L = zeros(G.shape[0], G.shape[0]) D = ones(G.shape[0] + 1, 1) A = Matrix(G) return A, B, L, D
def transform_col_vector(V): print(V.shape) ones_vector = sp.ones(1, V.shape[0]) print(ones_vector.shape) V = V * ones_vector V = V.T return V
def calc_weights(self, lhs_matrix, num_columns): """Calculate log-mean divisia weights Args: lhs_matrix (Symbolic Matrix): Matrix representing the LHS variable (the variable to decompose) symbolicly Returns: weights (Symbolic Matrix): The log-mean divisia weights """ lhs_total = lhs_matrix * sp.ones(lhs_matrix.shape[1], 1) print('lhs_total:', lhs_total) lhs_total = self.transform_col_vector(lhs_total) print('lhs_total tiled:', lhs_total) sp.pprint(lhs_total) print(lhs_total.shape) sp.pprint(lhs_matrix) print(lhs_matrix.shape) # lhs_total = sp.HadamardPower(lhs_total, -1) lhs_share = lhs_total * lhs_matrix print(lhs_share.shape) shift_matrix, long_matrix = self.shift_matrices(lhs_matrix) shift_share, long_share = self.shift_matrices(lhs_share) log_mean_matrix = self.logarithmic_average(long_matrix, shift_matrix) log_mean_matrix_total = log_mean_matrix * sp.ones( log_mean_matrix.shape[1], 1) log_mean_share = self.logarithmic_average(long_share, shift_share) log_mean_share_total = log_mean_share * sp.ones( log_mean_share.shape[1], 1) if self.model == 'additive': weights = self.additive_weights(log_mean_matrix, log_mean_matrix_total, log_mean_share_total) elif self.model == 'multiplicative': weights = self.multiplicative_weights(log_mean_matrix, log_mean_share, log_mean_share_total, log_mean_matrix_total) return weights
def elementary_weight(tree,s,arrays,method): """ Constructs elementary weights for a Volterra Runge-Kutta method, supposing the row sum condition. The output needs to be multiplied by b^T and equated to LHS to obtain the order condition. It is used by gen_order_conditions in vrk_methods INPUT: - tree -- input tree, must be a RootedTree. - s -- number of stages - arrays -- it depends on the method input, is a list containing two or three arrays, the order should be: c,A,e,D (if VRK) c,A,d (if BVRK) or c,A if (if PVRK) - method -- select which type of method to use: VRK, BVRK or if a PVRK method is wanted, the three must be created with the xa='a' flag. OUTPUT: it is a column vector belonging to <type 'numpy.ndarray'> e.g. like array([[],...,[]], dtype=object) """ from sympy import eye, ones if tree=='': return '' u=np.array(ones((s,1))) #np.ones((s, 1), dtype=np.int) if tree=='a': return u # Matrix(u) I=np.array(eye(s)) # np.eye(s, dtype=np.int) ew=u.copy() c=arrays[0] A=arrays[1] if method=='VRK': d=arrays[2] D=arrays[3] elif method=='BVRK': d=arrays[2] else: #method=='PVRK' d=arrays[0] nx,na,subtrees=tree._parse_subtrees() ew*=c**na #na and nx can also be zero, then we have a vector of ones. ew*=d**nx # Two curly bracket contain at least a symbol, 'a' or 'x', i.e {} is not a leaf if len(subtrees)>0: for subtree in subtrees: if method=='VRK': ew=ew*_elem_weight_sub3(subtree,method,c,D,A,I,u) else: ew=ew*_elem_weight_sub3(subtree,method,c,d,A,I,u) return ew #returns a column
def exp_so3_symbols(rotvec): epsilons = EPSILON * sympy.ones(3, 1) # add 'epsilons' to 'rotvec' directly # ZeroDivision occurs in grad calculation if we add EPSILON to 'theta' # in the denominator theta = Matrix(rotvec + epsilons).norm() K = tangent_so3(rotvec / theta) I = sympy.eye(3) return I + sympy.sin(theta) * K + (1-sympy.cos(theta)) * K * K
def dirac(): A = 0.1974 # Fermi velocity kx = sp.Symbol('kx', real=True) ky = sp.Symbol('ky', real=True) dx = -ky / (2 * (kx**2 + ky**2)) dy = kx / (2 * (kx**2 + ky**2)) prex = dx * sp.ones(2, 2) prey = dy * sp.ones(2, 2) dirac_system = cued.hamiltonian.BiTeBandstructure(vF=A, prefac_x=prex, prefac_y=prey, flag='dipole') return dirac_system
def construct_beta(Kbeta): # symbole associé au petit t (c'est à dire l'instant dans la période de suivi) t = sy.Symbol("t") # smbole associé au grand T (c'est à dire la durée de suivie) s = sy.Symbol("s") syPhi = sy.ones(Kbeta, 1) syb = sy.ones(1, Kbeta) b = [[] for k in range(Kbeta)] v = [np.arange(np.sqrt(Kbeta)), np.arange(np.sqrt(Kbeta))] expo = cg.expandnp(v) for x in range(len(expo[:, 0])): syPhi[x] = (t ** expo[x, 0]) * (s ** expo[x, 1]) syb[x] = sy.Symbol("b" + str(x)) b[x] = sy.Symbol("b" + str(x)) syBeta = syb * syPhi syBeta = syBeta[0, 0] arg = [t, s] + b Beta_fonc_est = sy.lambdify(tuple(arg), syBeta, "numpy") return Beta_fonc_est
def _pressure_tensor(grid): press = [Symbol('flux[%d]' % i) for i in range(grid.dim * (grid.dim + 1) / 2)] P = sympy.ones(grid.dim) # P_ab - rho cs^2 \delta_ab k = 0 for i in range(grid.dim): for j in range(i, grid.dim): P[i, j] = press[k] P[j, i] = press[k] k += 1 return P
def expectation(lam): p = Matrix([[-prob(i, j, lam) for j in range(k)] for i in range(k)]) for i in range(k): p[(k + 1) * i] = -sum(p.row(i)) + (Fraction( lam, n))**(k - i) * (Fraction(n - lam, n))**(n - k + i) return next( iter( linsolve( (p, ones(k, 1)), symbols(', '.join(['x_{}'.format(i) for i in range(k)])))))[0]
def BodyVelocity(self): V = sym.ones(6, 1) V[:3, 0] = self.R.T * self.t.diff(t) # Angular velocities skew symetric matrix S = self.R.T * self.R.diff(t) V[3, 0] = S[2, 1] V[4, 0] = S[0, 2] V[5, 0] = S[1, 0] return V
def z(A): """Return the (symbolic) vector of rates toward absorbing state. Args: A (SymPy dxd-matrix): compartment matrix Returns: SymPy dx1-matrix: :math:`\\bf{z} = -B^T\\,\\bf{1}` """ o = ones(A.rows, 1) return -A.transpose()*o
def z(B): """Return the (symbolic) vector of rates toward absorbing state. Args: B (SymPy dxd-matrix): compartment matrix Returns: SymPy dx1-matrix: :math:`z = -B^T\\,\\mathbf{1}` """ o = ones(B.rows, 1) return -B.transpose() * o
def weighted_term(weight, term): """Calculate components from dot product of weights and term Args: weight (MatrixSymbol): normalized log-mean divisia weights term (MatrixSymbol): The effect of the component (RHS) variable on the change in the LHS variable """ weighted_term = sp.matrix_multiply_elementwise(weight, term).doit() ones_ = sp.ones(weighted_term.shape[1], 1) component = weighted_term * ones_ return component
def run_batch(self, loop_num): # check if learned val is one of learnable param in func i = loop_num s = (i) * self.bs f = (i + 1) * self.bs if (i + 1) * self.bs < self.x.shape[0] + 1 else self.x.shape[0] + 1 #--------create matrixsymbol and pass in value of matrix # y = MatrixSymbol('y', self.y[s:f].shape[0],self.y[s:f].shape[1] ) # x = MatrixSymbol('x', self.x[s:f].shape[0], self.x[s:f].shape[1]) y = Matrix(self.y[s:f]) x = Matrix(self.x[s:f]) beta_sym = symbols(f'beta0:{self.beta.shape[1]}') # BETA = tuple of length = 1 * p beta = Matrix(np.array(beta_sym)) loss_func = (y - (x * beta)) * ones(beta.shape[1], 1) loss_func = ones(1, loss_func.shape[0]) * square_matrix_element_wise(loss_func) # loss_func = ones(1, loss_func.shape[0]) * square_matrix_element_wise(loss_func) # mean # loss_func = np.random.rand(1,1) penalty = self.lmda * (ones(1, beta.shape[0]) * square_matrix_element_wise(beta)) if self.l1 else 0 return loss_func + penalty
def lagrange(self, nodes): """ Lagrange polynomial """ length = len(nodes) r = sympy.Symbol('r') phi = sympy.ones(1, length) for k in range(length): for l in range(length): if (k != l): phi[k] *= (r - nodes[l])/(nodes[k] - nodes[l]) return phi
def test_zeros_ones_fill(): n, m = 3, 5 a = zeros( (n, m) ) a.fill( 5 ) b = 5 * ones( (n, m) ) assert a == b assert a.rows == b.rows == 3 assert a.cols == b.cols == 5 assert a.shape == b.shape == (3, 5)
def test_speed(): max_nodes = 20 min_nodes = 1 n = min_nodes times = [] while n <= max_nodes: nodes = list(range(n)) G_bus = sp.ones(n) B_bus = sp.ones(n) t_start = time.time() F, Jaco, Fxx, Jxx, VM, VA, P, Q, Node_index = create_powermismatch(G_bus, B_bus, nodes) times.append(time.time() - t_start) n+=1 plt.plot(range(min_nodes, max_nodes+1), times, 'o') plt.show()
def test_zeros_ones_fill(): n, m = 3, 5 a = zeros((n, m)) a.fill(5) b = 5 * ones((n, m)) assert a == b assert a.lines == b.lines == 3 assert a.cols == b.cols == 5 assert a.shape == b.shape == (3, 5)
def __init__(self, DH): #DH = [d,a,theta,alpha] assert len(DH) == 4 dh_ = list() type_ = type(DH[0]) for i in range(len(DH)): if not isinstance(DH[i], type_): sys.exit( "Denavit Hartenberg parameters must be from same type per joint" ) if isinstance(DH[i], str): # dh_.append(sp.Symbol(DH[i])) #string else: if i is 2 or i is 3: dh_.append(DH[i] * np.pi / 180) #number else: dh_.append(DH[i]) if type_ is str: self.H = sp.Matrix(sp.ones(4, 4)) c = sp.cos s = sp.sin else: self.H = np.matrix(np.ones((4, 4))) c = np.cos s = np.sin #First Row self.H[0, 0] = c(dh_[2]) self.H[0, 1] = -s(dh_[2]) * c(dh_[3]) self.H[0, 2] = s(dh_[2]) * s(dh_[3]) self.H[0, 3] = c(dh_[1]) * dh_[1] #Second Row self.H[1, 0] = s(dh_[2]) self.H[1, 1] = c(dh_[2]) * c(dh_[3]) self.H[1, 2] = -c(dh_[2]) * s(dh_[3]) self.H[1, 3] = s(dh_[2]) * dh_[1] #THird Row self.H[2, 0] = 0 self.H[2, 1] = s(dh_[3]) self.H[2, 2] = c(dh_[3]) self.H[2, 3] = dh_[0] #Forth Row self.H[3, 0] = 0 self.H[3, 1] = 0 self.H[3, 2] = 0 self.H[3, 3] = 1
def Pre_Comp_YX(L, T, Xdata, Y, Kbeta, J): t = sy.Symbol("t") s = sy.Symbol("s") # Récupération des variables et paramètres N = len(L) D = len(L[0]) # ----------------- Construction de la base fonctionnelle syPhi = sy.ones(Kbeta ** 2, 1) syb = sy.ones(1, Kbeta ** 2) v = [np.arange(Kbeta), np.arange(Kbeta)] expo = cg.expandnp(v) Phi_fonc = [[] for j in range(Kbeta ** 2)] for x in range(len(expo[:, 0])): syPhi[x] = (t ** expo[x, 0]) * (s ** expo[x, 1]) Phi_fonc[x] = sy.lambdify((t, s), syPhi[x], "numpy") syb[x] = sy.Symbol("b" + str(x)) syBeta = syb * syPhi Phi_mat = Comp_Phi(Phi_fonc, T, J) I_pen = J22_fast(syPhi, np.max(T), 50)[3] # ----------------- Construction des noyaux et leurs dérivées # Construction de la forme du noyau el1 = sy.Symbol("el1") per1 = sy.Symbol("per1") sig1 = sy.Symbol("sig1") args1 = [el1, per1, sig1] el2 = sy.Symbol("el2") sig2 = sy.Symbol("sig2") args2 = [el2, sig2] syk = cg.sy_Periodic((s, t), *args1) + cg.sy_RBF((s, t), *args2) args = [t, s] + args1 + args2 # Dérivation et construction des fonctions vectorielles associées k_fonc = sy.lambdify(tuple(args), syk, "numpy") n_par = len(args) - 2 k_der = [[] for i in range(n_par)] for i in range(n_par): func = syk.diff(args[i + 2]) k_der[i] = sy.lambdify(tuple(args), func, "numpy") return (Phi_mat, k_fonc, k_der, I_pen)
def lambdifyz(symbols, expr, modules="numpy"): """ Circumvents a bug in lambdify where silent variables will be simplified and therefore aren't broadcasted. https://github.com/sympy/sympy/issues/5642 Use an extra argument = 0 when calling """ assert isinstance(expr, sp.Matrix) z = sp.symbols("z") thesymbols = list(symbols) thesymbols.append(z) exprz = expr + z * sp.prod(symbols) * sp.ones(expr.shape[0], expr.shape[1]) fz = sp.lambdify(thesymbols, exprz, modules=modules) return fz
def cum_dist_func(beta, A, Qt): """Return the (symbolic) cumulative distribution function of phase-type. Args: beta (SymPy dx1-matrix): initial distribution vector A (SymPy dxd-matrix): transition rate matrix Qt (SymPy dxd-matrix): Qt = :math:`e^{t\\,\\bf{A}}` Returns: SymPy expression: cumulative distribution function of PH(:math:`\\bf{\\beta}`, :math:`\\bf{A}`) :math:`F_T(t) = 1 - \\bf{1}^T\\,e^{t\\,\\bf{A}}\\,\\bf{\\beta}` """ o = ones(1, A.cols) return 1 - (o * (Qt * beta))[0]
def nth_moment(beta, A, n): """Return the (symbolic) nth moment of the phase-type distribution. Args: beta (SymPy dx1-matrix): initial distribution vector A (SymPy dxd-matrix): transition rate matrix n (positive int): order of the moment Returns: SymPy expression: nth moment of PH(:math:`\\bf{\\beta}`, :math:`\\bf{A}`) :math:`\mathbb{E}[T^n] = (-1)^n\\,n!\\,\\bf{1}^T\\,\\bf{A}^{-1}\\,\\bf{\\beta}` """ o = ones(1, A.cols) return ((-1)**n*factorial(n)*o*(A**-n)*beta)[0]
def __init__(self, times, A0, k1, kinv, k2, using_sympy=False): """Generates baseline/true dataset of C concentration over time based on the provided parameters Args: times (array): times at which to evaluate C throughout calculations (should never be changed after being set) A0 (float): initial value of concentratin of A (should never be changed after being set) k1 (float): true value of parameter k1 kinv (float): true value of parameter kinv k2 (float): true value of parameter k2 using_sympy (bool): whether or not to generate gradient and hessian functions of the ob. fn. from symbolic representations """ self._A0 = A0 self._TIMES = times self._Cs = self.gen_timecourse(k1, kinv, k2) self.sympy_lsq_of_f = None self.sympy_lsq_of_gradient = None self.sympy_lsq_of_hessian = None if using_sympy: # set up sympy objective function k1, kinv, k2 = sympy.symbols('k1,kinv,k2') alpha = (k1 + kinv + k2 + ((k1 + kinv + k2)**2 - 4 * k1 * k2)**0.5) / 2 beta = (k1 + kinv + k2 - ((k1 + kinv + k2)**2 - 4 * k1 * k2)**0.5) / 2 sympy_times = sympy.Matrix(times).transpose() Cs_true = sympy.Matrix(self._Cs).transpose() # Cs = sympy.zeros(times.shape[0], 1) ones = sympy.ones( 1, times.shape[0] ) # for adding the time-independent term at each time Cs = self._A0 * ( ones * k1 * k2 / (alpha * beta) + (-alpha * sympy_times).applyfunc(sympy.exp) * k1 * k2 / (alpha * (alpha - beta)) - (-beta * sympy_times).applyfunc(sympy.exp) * k1 * k2 / (beta * (alpha - beta))) # # if we've already constructed and compiled the functions from sympy, just reload # # jk doesn't work # symbolic_lsq_of = None # if isfile("./data/symbolic-of.dill"): # symbolic_lsq_of = dill.load(open("./data/symbolic-of.dill", 'r')) # else: # symbolic_lsq_of = ObjectiveFunction(sum((Cs - Cs_true).applyfunc(lambda x:x*x)), [k1, kinv, k2]) # dill.dump(symbolic_lsq_of, open("./data/symbolic-of.dill", 'w')) symbolic_lsq_of = ObjectiveFunction( sum((Cs - Cs_true).applyfunc(lambda x: x * x)), [k1, kinv, k2]) self.sympy_lsq_of_f = symbolic_lsq_of.f self.sympy_lsq_of_gradient = symbolic_lsq_of.gradient self.sympy_lsq_of_hessian = symbolic_lsq_of.hessian
def getMatElemElasticity(dim=2): eps_ii = lamb*sympy.ones(dim, dim) + 2*mu*sympy.eye(dim) dimC = dim + 1 if dim==2 else 2*dim C = sympy.zeros(dimC, dimC) C[:dim, :dim] = eps_ii if dim == 2: C[-1, -1] = mu elif dim == 3: for i in range(1, dim+1): C[-i, -i] = mu phi = basis_function[dim] B = sympy.zeros(C.shape[0], dim*len(phi)) deriv = [x, y, z] for j in range(dim): for i in range(len(phi)): B[j, dim*i + j] = phi[i].diff(deriv[j]) if dim == 2: for i in range(len(phi)): B[-1, dim*i] = phi[i].diff(y) B[-1, dim*i + 1] = phi[i].diff(x) elif dim == 3: for i in range(len(phi)): B[-3, dim*i] = phi[i].diff(y) B[-3, dim*i + 1] = phi[i].diff(x) B[-2, dim*i] = phi[i].diff(z) B[-2, dim*i + 2] = phi[i].diff(x) B[-1, dim*i + 1] = phi[i].diff(z) B[-1, dim*i + 2] = phi[i].diff(y) A = B.T*C*B output = sympy.zeros(dim*len(phi), dim*len(phi)) for i in range(A.shape[0]): for j in range(A.shape[1]): #A[i, j] = A[i, j].together().factor() if dim == 2: output[i, j] = sympy.integrate(A[i, j], (y, 0., hy), (x, 0., hx)).expand() elif dim == 3: output[i, j] = sympy.integrate(A[i, j], (z, 0., hz), (y, 0., hy), (x, 0., hx)).expand() output[i, j].together().factor() #return sympy.lambdify((hx, hy, hz, lamb, mu), output, "numpy") return output
def basis(self): dofs = self.number_of_dofs() phi = sp.ones(1, dofs) p = self.p phi[1] = self.x / self.h phi[2] = self.y / self.h if p > 1: start = 3 for i in range(2, p + 1): for j, k in zip(range(start, start + i), range(start - i, start)): phi[j] = phi[k] * phi[1] phi[start + i] = phi[start - 1] * phi[2] start += i + 1 return phi
def basis(self, p=None): p = self.p if p is None else p dofs = self.number_of_dofs(p=p) phi = sp.ones(1, dofs) phi[1] = (self.x - self.barycenter[0]) / self.h phi[2] = (self.y - self.barycenter[1]) / self.h if p > 1: start = 3 for i in range(2, p + 1): for j, k in zip(range(start, start + i), range(start - i, start)): phi[j] = phi[k] * phi[1] phi[start + i] = phi[start - 1] * phi[2] start += i + 1 return phi
def cholesky(A): """ # A is positive definite mxm """ assert A.shape[0] == A.shape[1] # assert all(A.eigenvals() > 0) m = A.shape[0] N = deepcopy(A) D = ones(*A.shape) for i in xrange(m - 1): for j in xrange(i + 1, m): N[j, i] = N[i, j] D[j, i] = D[i, j] n, d = ratior(N[i, j], D[i, j], N[i, i], D[i, i]) N[i, j], D[i, j] = n, d for k in xrange(i + 1, m): for l in xrange(k, m): n, d = multr(N[k, i], D[k, i], N[i, l], D[i, l]) N[k, l], D[k, l] = subr(N[k, l], D[k, l], n, d) return N, D
def lagrangeDeri(self, nodes): """ Lagrange matrix at the nodes is just an Identity We'll come back to interpolation at points other than nodes at a later time Here we create derivative operator at the nodes Lagrange polynomial is phi = Product(l, l.neq.k) (r - r_l)/(r_k - r_l) r_i are the nodes """ length = len(nodes) r = sympy.Symbol('r') phi = sympy.ones(1, length) dPhi = sympy.zeros(length, length) for k in range(length): for l in range(length): if (k != l): phi[k] *= (r - nodes[l])/(nodes[k] - nodes[l]) for k in range(length): for l in range(length): dPhi[k, l] = sympy.diff(phi[l]).evalf(subs = {r: nodes[k]}) return dPhi
def relaxation_local(self, m, with_rel_velocity=False): """ Return symbolic expression which computes the relaxation operator. Parameters ---------- m : SymPy Matrix indexed objects for the moments with_rel_velocity : boolean check if the scheme uses relative velocity. (default is False) """ if with_rel_velocity: eq = (self.Tu*self.eq).subs(list(zip(self.mv, m))) else: eq = self.eq.subs(list(zip(self.mv, m))) relax = (sp.ones(*self.s.shape) - self.s).multiply_elementwise(sp.Matrix(m)) + self.s.multiply_elementwise(eq) alltogether(relax) return Eq(m, relax)
def J22(syPhi, Tmax): # taille de la base fonctionnelle Kbeta = len(syPhi) # symbole associé au petit t (c'est à dire l'instant dans la période de suivi) t = sy.Symbol("t") # smbole associé au grand T (c'est à dire la durée de suivie) s = sy.Symbol("s") deb = time.clock() Phi = sy.ones(Kbeta, 1) for i in range(Kbeta): Phi[i] = syPhi[i] Phi_dsds = Phi.diff(s, s) Phi_dsdt = Phi.diff(s, t) Phi_dtdt = Phi.diff(t, t) Is = np.zeros((Kbeta, Kbeta), float) Ic = np.zeros((Kbeta, Kbeta), float) It = np.zeros((Kbeta, Kbeta), float) def gfun(x): return 0 def hfun(x): return x for i in range(Kbeta): for j in range(Kbeta): func = sy.lambdify((t, s), Phi_dsds[j] * Phi_dsds[i], "numpy") Is[i, j] = integrate.dblquad(func, 0.0, Tmax, gfun, hfun, epsabs=5e-03)[0] func = sy.lambdify((t, s), Phi_dsdt[j] * Phi_dsdt[i], "numpy") Ic[i, j] = integrate.dblquad(func, 0.0, Tmax, gfun, hfun, epsabs=5e-03)[0] func = sy.lambdify((t, s), Phi_dsdt[j] * Phi_dtdt[i], "numpy") It[i, j] = integrate.dblquad(func, 0.0, Tmax, gfun, hfun, epsabs=5e-03)[0] print(str(time.clock() - deb) + " secondes de calcul") I_pen = Is + It + 2 * Ic return (Is, Ic, It, I_pen)
def randomWeightMatrix(x, y): mat = ones([x, y]) f = lambda x: random.uniform(0, 1) * x mat = mat.applyfunc(f) return mat
def _look_for_case_tree(robo,symo): try_paul_str = ("\r\n\r\n# Branch {0}") + \ ("of the robot cannot be solved by PIEPER METHOD. ") + \ ("This branch has less than 6 joints. ") + \ ("Try Paul Method \r\n\r\n") End_joints = [] X_joints = [] pieper_joints = [] j = [] for i in range(robo.NJ+1): j.append(i) for joint in range(1, len(robo.ant)): if j[joint] not in robo.ant and robo.sigma[joint] != 2: End_joints.append(j[joint]) branches = len(End_joints) symo.write_line("# The tree structure robot has {0} branches.".format(branches)) [bool_fail, bool_prism, bool_spherical] = [zeros(1, branches), zeros(1, branches), zeros(1, branches)] [pieper_branches, com_key] = [999*ones(1, branches), 999*ones(1, branches)] num_prism = zeros(1, branches) for i in range(branches): f_joint = End_joints[i] c = 0 globals()["bran"+str(i)] = [0]*max(robo.ant) while f_joint != 0: globals()["bran"+str(i)][c] = f_joint f_joint = robo.ant[f_joint] c += 1 globals()["bran"+str(i)] = [x for x in globals()["bran"+str(i)] if x != 0] globals()["bran"+str(i)] = globals()["bran"+str(i)][::-1] if len(globals()["bran"+str(i)]) > 6: symo.write_line( ("\r\n\r\n# Branch {0} ".format(i+1)) + \ ("of the robot cannot be solved by PIEPER METHOD. ") + \ ("This branch is redundant. \r\n\r\n") ) bool_fail[i] = 1 elif len(globals()["bran"+str(i)]) < 6: symo.write_line(try_paul_str.format(i+1)) bool_fail[i] = 1 else: bool_fail[i] = 0 for k in range(len(globals()["bran"+str(i)])): num_prism[i] = num_prism[i] + robo.sigma[globals()["bran"+str(i)][k]] if num_prism[i] > 3: symo.write_line( ("\r\n\r\n# Branch {0} ".format(i+1)) + \ ("of the robot cannot be solved by PIEPER METHOD. ") + \ ("It is redundant (more than 3 prismatic joints). \r\n\r\n") ) bool_fail[i] = 1 elif num_prism[i] == 3: pieper_branches[i] = i bool_prism[i] = 1 p_joints = [] joints = [] for joint in range(len(globals()["bran"+str(i)])): if robo.sigma[globals()["bran"+str(i)][joint]] == 1: pieper_joints.append(globals()["bran"+str(i)][joint]) p_joints.append(globals()["bran"+str(i)][joint]) else: X_joints.append(globals()["bran"+str(i)][joint]) joints.append(robo.sigma[globals()["bran"+str(i)][joint]]) joint_type = tuple(joints) if joint_type in joint_com: com_key[i] = joint_com[joint_type] symo.write_line( ("\r\n\r\n# PIEPER METHOD: Branch {0}".format(i+1)) + \ (" is decoupled with 3 prismatic joints ") + \ ("positioned at {0} \r\n\r\n".format(p_joints)) ) else: for m in range(2, len(globals()["bran"+str(i)])): if (robo.sigma[globals()["bran"+str(i)][m-1]] == 0) \ and (robo.sigma[globals()["bran"+str(i)][m]] == 0) \ and (robo.sigma[globals()["bran"+str(i)][m+1]] == 0): if (robo.d[globals()["bran"+str(i)][m]] == 0) \ and (robo.d[globals()["bran"+str(i)][m+1]] == 0) \ and (robo.r[globals()["bran"+str(i)][m]] == 0): if (sin(robo.alpha[globals()["bran"+str(i)][m]]) != 0) \ and (sin(robo.alpha[globals()["bran"+str(i)][m+1]]) != 0): pieper_branches[i] = i pieper_joints = [ globals()["bran"+str(i)][m-1], globals()["bran"+str(i)][m], globals()["bran"+str(i)][m+1] ] joints = [] joint = globals()["bran"+str(i)] for ji in range(len(joint)): if joint[ji] not in pieper_joints: X_joints.append(globals()["bran"+str(i)][ji]) joints.append(robo.sigma[globals()["bran"+str(i)][ji]]) joint_type = tuple(joints) if joint_type in joint_com: com_key[i] = joint_com[joint_type] symo.write_line( ("\r\n\r\n# PIEPER METHOD: ") + \ ("Branch{0}".format(i+1)) + \ (" is decoupled with a ") + \ ("spherical joint composed by ") + \ ("joints {0} \r\n\r\n".format(pieper_joints)) ) bool_spherical[i] = 1 break elif m == 5: bool_fail[i] = 1 symo.write_line(try_paul_str.format(i+1)) elif m == 5: bool_fail[i] = 1 symo.write_line(try_paul_str.format(i+1)) elif m == 5: bool_fail[i] = 1 symo.write_line(try_paul_str.format(i+1)) bools = [bool_fail, bool_prism, bool_spherical] pieper_branches = [x for x in pieper_branches if x != 999] com_key = [x for x in com_key if x != 999] return bools, pieper_branches, pieper_joints, X_joints, com_key
T = Matrix([[0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1]]) F = Matrix(len(p), len(fs), lambda i, j: fs[j].subs({x: x-p[i][0], y: y-p[i][1]})) # P stands for scalar potential #pprint((Nu*G).multiply_elementwise(F), num_columns=200) P = [Matrix(1, len(p), lambda i, j: 0 if j == k else 1)*((Nu*G).multiply_elementwise(F)) for k in xrange(0, len(p))] #pprint(P) sensor_functions = T * (ones(1, len(p)) * (Nu * G).multiply_elementwise(F)).T # The only thing left is to substitute for sensor_index, sensor_function in enumerate(sensor_functions): # unpack coordinates expressions s_x, s_y = absolute_sensor_ps[sensor_index] print sensor_function.subs({x: s_x, y: s_y}) pprint(sensor_functions) # sensor_functions are functions which depend on absolute Sensor position. # Let us find expressions for every Sensor values. We need to call this function # providing sum of Sensor relative position plus associated Agents position
def test_empty_Matrix(): sT(ones(0, 3), "MutableDenseMatrix(0, 3, [])") sT(ones(4, 0), "MutableDenseMatrix(4, 0, [])") sT(ones(0, 0), "MutableDenseMatrix([])")
#drawGraph(edges11, edges2, filename = "graph_dead_end.pdf", labels = list('ABCDE')) #drawGraph(edges1, edges2, filename = "graphx.pdf", labels=['']*5, node_size=[100,200,300,400,500])#_probability M=get_stochastic_matrix(G) # rand surfer drawGraph(edges1, edges2, filename = "graph.pdf", labels = list('ABCDE')) v=Matrix([1,0,0,0,0]).T v_ = ([1,0,0,0,0], [0,0,0,0,1], [0, '\\frac{2}{5}','\\frac{2}{5}', '\\frac{1}{5}', 0]) for i in range(3): v= v_[i] drawGraph(edges1, edges2, filename = "graph_probability%d.pdf" %i, labels=v)# #v = M*v pr = sympy.ones(len(G.nodes()),1)/len(G.nodes()) node_size=map(int, list(5000*pr)) drawGraph(edges1, edges2, filename = "graph_tansmatr0.pdf", # labels=['']*5, node_size=node_size) for i in range(1,4): prp = M*pr # print r"""\only<%i>{{ \begin{{equation*}} # {2} = # {0} # \cdot # {1} # \end{{equation*}} }}""".format(*map(sympy.latex, (M, pr, prp))) % i # print "\n"*2 pr = prp node_size=map(int, list(5000*pr)) drawGraph(edges1, edges2, filename = "graph_tansmatr%d.pdf" % i, # labels=['']*5,
def get_stochastic_matrix(G): A = nx.adjacency_matrix(G.reverse(copy=True), nodelist=list('ABCDE')) k = Matrix((A.sum(axis=0)).astype(int)).applyfunc(lambda x: 1/x) A = Matrix(A.astype(int)) S = A.multiply_elementwise(sympy.ones(5,1)*k) return S
def Pre_Comp(L, T, Xdata, Y, Kbeta, J): t = sy.Symbol("t") s = sy.Symbol("s") # Récupération des variables et paramètres N = len(L) D = len(L[0]) # ----------------- INFERENCES DES PARAMS LONGITUDINAUX # print("[ ] Inférence des paramètres fonctionnels") model = pyGPs.GPR() kern1 = pyGPs.cov.RBF(log_ell=0.0, log_sigma=0.0) kern2 = pyGPs.cov.Periodic(log_ell=0.0, log_p=0.0, log_sigma=0.0) kern = pyGPs.cov.SumOfKernel(kern1, kern2) m = pyGPs.mean.Const() model.setPrior(mean=m, kernel=kern) model.setNoise(log_sigma=-2.30258) Theta = np.zeros((N, D, len(model.covfunc.hyp)), float) Gamma = np.zeros((N, D), float) moy_est = np.zeros((N, D), float) for i in range(N): for j in range(D): y = np.asarray(Xdata[i][j]) x = np.asarray(L[i][j]) try: model.optimize(x, y) moy_est[i, j] = model.meanfunc.hyp[0] Theta[i, j, :] = np.array(np.exp(model.covfunc.hyp)) Gamma[i, j] = np.exp(model.likfunc.hyp) except: # Problème d'inférence, paramètres défaut attribués moy_est[i, j] = np.mean(x) Theta[i, j, :] = np.array([0.05, np.std(x) ** 2, 0.05, 1.0, 0.0]) Gamma[i, j] = 1.0 pass # ----------------- RECUPERATION DES QUANTITES D'INTERET # print("[- ] Récupération des quantités d'intérêt") # Construction de la forme du noyau el1 = sy.Symbol("el1") sig1 = sy.Symbol("sig1") args1 = [el1, sig1] el2 = sy.Symbol("el2") per2 = sy.Symbol("per2") sig2 = sy.Symbol("sig2") args2 = [el2, per2, sig2] syk = cg.sy_RBF((s, t), *args1) + cg.sy_Periodic((s, t), *args2) args = [t, s] + args1 + args2 k_fonc = sy.lambdify(tuple(args), syk, "numpy") Psi = Comp_Psi(L, k_fonc, Theta, Gamma)[0] # ----------------- Construction de la base fonctionnelle # print("[-- ] Calcul des quantités d'intérêt") syPhi = sy.ones(Kbeta ** 2, 1) syb = sy.ones(1, Kbeta ** 2) v = [np.arange(Kbeta), np.arange(Kbeta)] expo = cg.expandnp(v) Phi_fonc = [[] for j in range(Kbeta ** 2)] for x in range(len(expo[:, 0])): syPhi[x] = (t ** expo[x, 0]) * (s ** expo[x, 1]) Phi_fonc[x] = sy.lambdify((t, s), syPhi[x], "numpy") syb[x] = sy.Symbol("b" + str(x)) syBeta = syb * syPhi I_pen = J22_fast(syPhi, np.max(T), 50)[3] # ----------------- Construction de l et V Un = np.ones(J + 1, float) Un[0] = 0.5 Un[J] = 0.5 Phi_mat = Comp_Phi(Phi_fonc, T, J) l = np.zeros((N, D * Kbeta ** 2), float) V = [[] for i in range(N)] vl = [[] for j in range(D)] for i in range(N): Phi_i = Phi_mat[(i * (J + 1)) : (i * (J + 1) + J + 1), :].T for j in range(D): Xij = Xdata[i][j] # Moyenne de F_ij estimée en amont Etaij = moy_est[i, j] t = L[i][j] grid = T[i] * 1.0 * np.arange(J + 1) / J vec = cg.expandnp([t, grid]) args = list(vec.T) + list(Theta[i, j, :]) K_ij = np.apply_along_axis(k_fonc, 0, *args).reshape(J + 1, len(t)) K_ij[0, :] = K_ij[0, :] * 0.5 K_ij[J, :] = K_ij[J, :] * 0.5 KPsi = K_ij.dot(Psi[i][j]) l[i, (j * Kbeta ** 2) : ((j + 1) * Kbeta ** 2)] = ( Phi_i.dot(KPsi.dot(Xij - Etaij) + Etaij * Un).reshape(-1) / J ) # on calcule pour k_ij, la matrice des k(s,t) pour s,t dans la grille de [0,Ti] vec = cg.expandnp([grid, grid]) args = list(vec.T) + list(Theta[i, j, :]) k_ij = np.apply_along_axis(k_fonc, 0, *args).reshape(J + 1, J + 1) k_ij[0, :] = k_ij[0, :] * 0.5 k_ij[J, :] = k_ij[J, :] * 0.5 k_ij[:, 0] = k_ij[:, 0] * 0.5 k_ij[:, J] = k_ij[:, J] * 0.5 Cov_FF = k_ij - KPsi.dot(K_ij.T) vl[j] = Phi_i.dot(Cov_FF).dot(Phi_i.T) / J ** 2 V[i] = sc.sparse.block_diag(tuple(vl)) # On ajoute une matrice diagonale pour rendre V[i] définie positive, mais on fait en sorte que ses valeurs propres soient petites par rapport à celles de V[i] pour ne pas trop affecter la vraisemblances sur l'espace autour de 0. # V[i]=V[i]+np.eye(D*Kbeta**2)*0.01*np.trace(V[i].toarray())/(D*Kbeta**2) return (l, V, I_pen)
# x**3, # x**4, # x**5, # x**6] F = Matrix(number_of_matters, len(fs), lambda i, j: fs[j].subs({x: x-ps[i][0], y: y-ps[i][1]})) P = [Matrix(1, number_of_matters, lambda i, j: 0 if j == k else 1)*((Nu*G).multiply_elementwise(F)) for k in xrange(number_of_matters)] R = ReferenceFrame('R') M = [(P[i]*E*Nu[i, :].T)[0].subs({x: R[0], y: R[1]}) for i in xrange(0, number_of_matters)] W = [gradient(M[i], R).to_matrix(R).subs({R[0]: x, R[1]: y})[:2] for i in xrange(number_of_matters)] # Natural laws part natural_field = diag(*(ones(1, number_of_matters) * ((Nu*G).multiply_elementwise(F)))) force_is_present = natural_field.applyfunc( lambda exp: Piecewise((1.0, exp > 0.0), (0.0, True)) ) natural_influence = (Upsilon * Alpha * natural_field + S * Alpha)*force_is_present*ones(len(fs), 1) pending_transformation_vector = Omicron.transpose()*natural_influence Nu_new = (Nu - get_matrix_of_converting_atoms(Nu, ps, pending_transformation_vector) + get_matrix_of_converted_atoms(Nu, ps, pending_transformation_vector, natural_influence, Omicron, D)) delta_t = Symbol('Delta_t')
def J22_fast(syPhi, Tmax, J): # taille de la base fonctionnelle Kbeta = len(syPhi) # symbole associé au petit t (c'est à dire l'instant dans la période de suivi) t = sy.Symbol("t") # smbole associé au grand T (c'est à dire la durée de suivie) s = sy.Symbol("s") deb = time.clock() Phi = sy.ones(Kbeta, 1) for i in range(Kbeta): Phi[i] = syPhi[i] # dérivation de la base fonctionnelle (Phi_dsds, Phi_dsdt, Phi_dtdt) = (Phi.diff(s, s), Phi.diff(s, t), Phi.diff(t, t)) (Phi_mat_dsds, Phi_mat_dsdt, Phi_mat_dtdt) = ( np.zeros(((J + 1) ** 2, Kbeta), float), np.zeros(((J + 1) ** 2, Kbeta), float), np.zeros(((J + 1) ** 2, Kbeta), float), ) # Grille d'intégration carré (on retire le triangle supérieur plus loin) t_arg = sc.linspace(0, Tmax, J + 1) s_arg = t_arg args = cg.expandnp([t_arg, s_arg]).T for i in range(Kbeta): func = sy.lambdify((t, s), Phi_dsds[i], "numpy") Phi_mat_dsds[:, i] = np.apply_along_axis(func, 0, *args) func = sy.lambdify((t, s), Phi_dsdt[i], "numpy") Phi_mat_dsdt[:, i] = np.apply_along_axis(func, 0, *args) func = sy.lambdify((t, s), Phi_dtdt[i], "numpy") Phi_mat_dtdt[:, i] = np.apply_along_axis(func, 0, *args) (Is, Ic, It) = (np.zeros((Kbeta, Kbeta), float), np.zeros((Kbeta, Kbeta), float), np.zeros((Kbeta, Kbeta), float)) Un = np.ones(J + 1, float) # matrice triangulaire inférieure d'intégration a = cg.expandnp([np.arange(J + 1), np.arange(J + 1)]) triang = np.asarray(a[:, 0] <= a[:, 1], float).reshape((J + 1, J + 1)) # Calcul des intégrales for i in range(Kbeta): for j in range(Kbeta): if i <= j: Is[i, j] = ( Un.dot( Phi_mat_dsds[:, j].reshape((J + 1, J + 1)) * Phi_mat_dsds[:, i].reshape((J + 1, J + 1)) * triang ).dot(Un) * (Tmax ** 2) / (J * (J + 1)) ) Ic[i, j] = ( Un.dot( Phi_mat_dsdt[:, j].reshape((J + 1, J + 1)) * Phi_mat_dsdt[:, i].reshape((J + 1, J + 1)) * triang ).dot(Un) * (Tmax ** 2) / (J * (J + 1)) ) It[i, j] = ( Un.dot( Phi_mat_dtdt[:, j].reshape((J + 1, J + 1)) * Phi_mat_dtdt[:, i].reshape((J + 1, J + 1)) * triang ).dot(Un) * (Tmax ** 2) / (J * (J + 1)) ) else: (Is[i, j], Ic[i, j], It[i, j]) = (Is[j, i], Ic[j, i], It[j, i]) I_pen = Is + It + 2 * Ic I_pen = I_pen + np.eye(Kbeta) * 0.001 * np.trace(I_pen) / Kbeta return (Is, Ic, It, I_pen)