def derMatrix(Bulk_Operators, Bdy_Operators, s=1): """ Generates a matrix in the same vein as Eq (2.10) of 1502.07217 First n_bulk elements are coefficients of p_k's Next n_bdy elements are coefficients of q_l's Last element is coefficient of a_1*a_2 Note that this matrix contains a mix of expressions and numbers FOLLOWING VARIABLES MUST BE DEFINED GLOBALLY BEFORE CALLING: table1, delta_1, delta_2, delta_12 """ Matrix = [] for i in range(1, M_max + 1): row = [] for Bulk_Op in Bulk_Operators: table_call = table1.table[0, i].subs({ "Delta": Bulk_Op, "Delta_12": delta_12, "Xi": 1.00 }) row.append(table_call) for Bdy_Op in Bdy_Operators: table_call = table1.table[1, i].subs({"Delta": Bdy_Op, "Xi": 1.00}) row.append(table_call) Xi = symbols('Xi') if s == 1: last_expr = Xi**((delta_1 + delta_2) / 2) last_elem = diff(last_expr, Xi, i).subs({"Xi": 1.00}).evalf() row.append(last_elem) Matrix.append(row) return np.array(Matrix)
def inhomoCoeffs(Bulk_Operators, Bdy_Operators, s=1): """ Generates the first equation as Eq (2.10) of 1502.07217 This is needed to calculate CFT data once dimensions are found. First n_bulk elements are coefficients of p_k's Next n_bdy elements are coefficients of q_l's Last element is coefficient of a_1*a_2 FOLLOWING VARIABLES MUST BE DEFINED GLOBALLY BEFORE CALLING: table1, delta_1, delta_2, delta_12 """ Row = [] for Bulk_Op in Bulk_Operators: table_call = table1.table[0, 0].subs({ "Delta": Bulk_Op, "Delta_12": delta_12, "Xi": 1.00 }) Row.append(table_call) for Bdy_Op in Bdy_Operators: table_call = table1.table[1, 0].subs({"Delta": Bdy_Op, "Xi": 1.00}) Row.append(table_call) if s == 1: Xi = symbols('Xi') last_expr = Xi**((delta_1 + delta_2) / 2) last_elem = last_expr.subs({"Xi": 1.00}).evalf() Row.append(last_elem) return np.array(Row)
def identity_block(self): identity_array = [-1] Xi = symbols("Xi") identity_expr = -1 * Xi**((delta_1 + delta_2) / 2) for n in range(1, M_max + 1): eval = diff(identity_expr, Xi, n).subs({"Xi": 1.00}).evalf() identity_array.append(eval) return identity_array
def define_3by3_matrix_inv_and_determinant(file_name): """ Constructs a 3 x 3 matrix and calculates the form of the determinant and inverse. """ A = sy.Matrix(3, 3, symbols('A:3:3')) A_inv = A.inv() A_det = A.det() df = pd.DataFrame({'A': [A], 'Determinant': [A_det], 'Inverse': [A_inv]}) df.to_csv(file_name + '.csv', index=True) return A, A_det, A_inv
def __init__(self, dim, M_max): self.dim = dim self.m_order = list(range(M_max+1)) Delta, Delta_12, Xi = symbols('Delta Delta_12 Xi') Bulk_expr = -1*(Xi**(Delta/2))*hyper([(Delta + Delta_12)/2 , (Delta - Delta_12)/2], [Delta + 1 - (dim/2)],-Xi) Bdy_expr = (Xi**(-Delta + (delta_1 + delta_2)/2))*hyper([Delta, Delta + 1 - (dim/2)], [2*Delta + 2 - (dim)], -Xi**(-1)) # if dim == 3: # Bdy_expr = (0.5/(Xi**0.5))*((4/(1 + Xi))**(Delta - 0.5))*(1 + (Xi/(1+Xi))**(0.5))**(-2*(Delta - 1)) Bulk_array = [Bulk_expr] Bdy_array = [Bdy_expr] for n in range(1, M_max + 1): Bulk_array.append(diff(Bulk_expr, Xi, n)) Bdy_array.append(diff(Bdy_expr, Xi, n)) self.table = np.array([Bulk_array, Bdy_array])
def define_6by6_matrix_inv_and_determinant(file_name): """ Constructs a 4 x 4 matrix and calculates the form of the determinant and inverse. """ time_start = time.time() A = sy.Matrix(6, 6, symbols('A:6:6')) A_inv = A.inv() A_det = A.det() time_end = time.time() df = pd.DataFrame({'A': [A], 'Determinant': [A_det], 'Inverse': [A_inv]}) df.to_csv(file_name + '.csv', index=True) print('Time taken to invert and calculate determinant : {}'.format( time_start - time_end)) return A, A_det, A_inv
from numanalysis.variational_proective.utilities.util import plotter from numanalysis.variational_proective.methods.methods import BubnovGalerkin from sympy import lambdify from numanalysis.variational_proective.functional.fun_sys import EvenOddBasis, BasisFunction, AnotherSystem from numpy import linspace from numpy.linalg import norm from sympy.abc import symbols from sympy.parsing.sympy_parser import ( parse_expr, standard_transformations, implicit_multiplication, ) transformations = standard_transformations + (implicit_multiplication, ) variable = symbols("x") a, b = 2, 5 b1, b2, b3 = 1, 2, 1 k1, k2 = 6, 3 c1, c2, c3 = 1, 2, 1 p1, p2 = 2, 1 d1, d2, d3 = 1, 1, 1 q1, q2 = 1, 0 a1, a2, a3, a4 = 6, 3, 1, 1 n1, n2, n3 = 2, 1, 4 alpha = a1 * (a**n1) + a2 * (a**n2) + a3 * (a**n3) + a4 beta = a1 * n1 * (a ** (n1 - 1)) + a2 * n2 * \ (a ** (n2 - 1)) + a3 * n3 * (a ** (n3 - 1)) gamma = a1 * (b**n1) + a2 * (b**n2) + a3 * (b**n3) + a4 delta = a1 * n1 * (b ** (n1 - 1)) + a2 * n2 * \ (b ** (n2 - 1)) + a3 * n3 * (b ** (n3 - 1))
""" Created on Thu Mar 12 16:29:10 2020 @author: SR917 """ import numpy as np import scipy as sp import matplotlib.pyplot as plt import pandas as pd import ast import ThreeHiggsModel_Analayse as THMA from sympy.abc import symbols import time #import according to how many variables are needed - Ex: for 1D import x, a, b t,x,y, z, w, h, a,b,c,d, e, f, g,h, l, m,n = symbols('t,x,y, z, w, h, a,b,c,d, e,f,g,h,l,m,n', real = True) def tidy_up(string): """ Format the strings of arrays to lists of lists """ temp1 = string.replace("array(","") temp2 = temp1.replace(")", "") output = ast.literal_eval(temp2) return output def obtained_roots(filename): """ Obatain roots from our homotopy continuation in format required
from sympy.integrals.transforms import inverse_laplace_transform from sympy.abc import symbols t, s = symbols('t,s', positive=True) ans1 = inverse_laplace_transform((1 / (s + 3)**3), s, t) print("18MEC24006-DENNY JOHNSON P") print(ans1) ans2 = inverse_laplace_transform((3 * s**2 + 10 * s - 6) / s**4, s, t) print(ans2) ans3 = inverse_laplace_transform(s / (s - 3)**5, s, t) print(ans3) ans4 = inverse_laplace_transform((2 * s - 11) / (s**2 + 4 * s + 8), s, t) print(ans4)
def define_4by4_matrix_inv_and_determinant(): A = sy.Matrix(4, 4, symbols('A:4:4')) return A, A.det(), A.inv()
""" #import functions import numpy as np import sympy as sy import scipy.integrate as spi from sympy.abc import symbols from sympy.utilities.lambdify import lambdify import itertools as it import time import iminuit as im import pandas as pd #import according to how many variables are needed - Ex: for 1D import x, a, b t,x,y, z, w, h, a,b,c,d, e, f, g,h = symbols('t,x,y, z, w, h, a,b,c,d, e,f,g,h', real = True) #construct homotopy def Homotopy(t, G, F, gamma): """ Constructs the Homotopy from the function to determine F, and the intial easy function G Gamma must be a complex number with absolute value 1 """ return [(1 - t)*G[i] + gamma*t*F[i] for i in range(len(G))] #construct starting polynomial def G(input_variables): """ Constructs easy starting polynomial with known roots depending on the dimensions of the input variables Parameters: