def num_modular_vf(self, bivector, function, mesh, pt_output=False, tf_output=False, dict_output=False): """ Calculates the modular vector field Z of a given Poisson bivector field P relative to the volume form f*Omega_0 defined as Z(g):= div(X_g) where Omega_0 = dx1^...^dx('dim'), f a non zero function and div(X_g) is the divergence respect to Omega of the Hamiltonian vector field X_g of f relative to P. Clearly, the modular vector field is Omega-dependent. If h*Omega is another volume form, with h a nowhere vanishing function on M, then Z' = Z - (1/h)*X_h, is the modular vector field of P relative to h*Omega. Parameters ========== :bivector: Is a Poisson bivector in a dictionary format with tuple type 'keys' and string type 'values'. :function: Is a function scalar h: M --> R that is a non zero and is a string type. :mesh: Is a numpy array where each value is a list of float values that representa a point in R^{dim}. :pt_output/tf_output: Is a boolean flag to indicates if the result is given in a tensor from PyTorch/TensorFlow, its default value is False. Returns ======= The default result is a NumPy array that contains all the evaluations of the modular vector field Z of a given Poisson bivector field P relative to the volume. This value can be converted to Tensor PyTorch, TensorFlow or dictionary for by setting their respective flag as True in the params.The result is a normal form in a dictionary format with integer type 'keys' and symbol type 'values'. Example ======== >>> import numpy as np >>> from poisson import NumPoissonGeometry >>> # Instance the class to dimension 3 >>> npg3 = NumericalPoissonGeometry(3) >>> # Defines a simple bivector >>> bivector = {e: f'1/2*(x1**2 + x2**2 + x3**2 + x4**2)' for e in tuple(itls.combinations(range(1, dim + 1), 2))} # noqa >>> mesh = np.array([[1., 1., 1.,]]) >>> # Evaluates the mesh into >>> npg3.num_modular_vf(bivector, 1, mesh) >>> [[[-2.] [ 0.] [ 2.]]] >>> npg3.num_modular_vf(bivector, 1, mesh, pt_output=True) >>> tf.Tensor( [[[-2.] [ 0.] [ 2.]]], shape=(1, 3, 1), dtype=float64) >>> npg3.num_modular_vf(bivector, 1, mesh, tf_output=True) >>> tensor([[[-2.], [ 0.], [ 2.]]], dtype=torch.float64) >>> npg3.num_modular_vf(bivector, 1, mesh, dict_output=True) >>> [{(1,): -2.0, (2,): 0.0, (3,): 2.0}] """ # Evaluates the modluar vector field in each point from mesh and save the result in Numpy array modular_vf = self.pg.modular_vf(bivector, function) dict_list = dict_mesh_eval(modular_vf, mesh, self.pg.coords) np_result = dicts_to_matrices(dict_list, self.pg.dim) # return the result in a TensorFlow tensor if the flag is True if tf_output: # TODO apply lambdify method to tensorflow return tf.convert_to_tensor(np_result) # return the result in a PyTorch tensor if the flag is True if pt_output: return torch.from_numpy(np_result) # return the result in dictionary type if dict_output: return dict_list # return the result in Numpy array return np_result
def num_flaschka_ratiu_bivector(self, casimirs_list, mesh, tf_output=False, pt_output=False, dict_output=False): """ Calculate a Poisson bivector from Flaschka-Ratui formula where all Casimir function is in "casimir" variable. This Poisson bivector is the following form: i_π Ω := dK_1^...^dK_m-2 where K_1, ..., K_m-2 are casimir functions and (M, Ω) is a diferentiable manifold with volument form Ω and dim(M)=m. Parameters ========== :casimirs_list: Is a list of Casimir functions where each element is a string type. :mesh: Is a numpy array where each value is a list of float values that representa a point in R^{dim}. :pt_output/tf_output: Is a boolean flag to indicates if the result is given in a tensor from PyTorch/TensorFlow, its default value is False. Returns ======= The default result is a NumPy array that contains all the evaluations of lineal normal form from a bivector. This value can be converted to Tensor PyTorch, TensorFlow or dictionary for by setting their respective flag as True in the params.The result is a normal form in a dictionary format with integer type 'keys' and symbol type 'values'. Example ======== >>> import numpy as np >>> from poisson import NumPoissonGeometry >>> # Instance the class to dimension 4 >>> npg4 = NumPoissonGeometry(4) >>> # Defines Casimir functions >>> casimirs = ['x1**2 +x2**2 +x3**2', 'x4'] >>> # Calculate a simple mesh >>> mesh = np.array([[1., 1., 1., 1.]]) >>> # Evaluates the mesh into >>> npg4.num_flaschka_ratiu_bivector(bivector, mesh) >>> [[[ 0. -2. 2. 0.] [ 2. 0. -2. 0.] [-2. 2. 0. 0.] [ 0. 0. 0. 0.]]] >>> npg4.num_flaschka_ratiu_bivector(bivector, mesh, pt_output=True) >>> tensor([[[ 0., -2., 2., 0.], [ 2., 0., -2., 0.], [-2., 2., 0., 0.], [ 0., 0., 0., 0.]]], dtype=torch.float64) >>> npg4.num_flaschka_ratiu_bivector(bivector, mesh, tf_output=True) >>> tf.Tensor( [[[ 0. -2. 2. 0.] [ 2. 0. -2. 0.] [-2. 2. 0. 0.] [ 0. 0. 0. 0.]]], shape=(1, 4, 4), dtype=float64) >>> npg4.num_flaschka_ratiu_bivector(bivector, mesh, dict_output=True) >>> [{(1, 2): -2.0, (1, 3): 2.0, (2, 3): -2.0}] """ flaschka_ratiu_bivector = self.pg.flaschka_ratiu_bivector( casimirs_list) # Evaluates the linear normal form from a bivector in each point from mesh and save the result in Numpy array dict_list = dict_mesh_eval(flaschka_ratiu_bivector, mesh, self.pg.coords) np_result = dicts_to_matrices(dict_list, self.pg.dim) # return the result in a PyTorch tensor if the flag is True if pt_output: return torch.from_numpy(np_result) # return the result in a TensorFlow tensor if the flag is True if tf_output: # TODO apply lambdify method to tensorflow return tf.convert_to_tensor(np_result) # return the result in dictionary type if dict_output: return dict_list # return the result in Numpy array return np_result
def num_linear_normal_form_R3(self, linear_bivector, mesh, tf_output=False, pt_output=False, dict_output=False): """ Evaluates a normal form for Lie-Poisson bivector fields on R^3 (modulo linear isomorphisms) in all points given of a mesh. Parameters ========== :linear_bivector: Is a Lie-Poisson bivector in a dictionary format with integer type 'keys' and string type 'values'. :mesh: Is a numpy array where each value is a list of float values that representa a point in R^{dim}. :pt_output/tf_output: Is a boolean flag to indicates if the result is given in a tensor from PyTorch/TensorFlow, its default value is False. Returns ======= The default result is a NumPy array that contains all the evaluations of lineal normal form from a bivector. This value can be converted to Tensor PyTorch, TensorFlow or dictionary for by setting their respective flag as True in the params.The result is a normal form in a dictionary format with integer type 'keys' and symbol type 'values'. Example ======== >>> import numpy as np >>> from poisson import NumPoissonGeometry >>> # Instance the class to dimension 3 >>> npg3 = NumPoissonGeometry(3) >>> # For bivector (3*x3 - x1)*Dx1^Dx2 - (x1 + 2*x2)*Dx1^Dx3 + (x1 + x2 - x3)*Dx2^Dx3 >>> bivector = {(1, 2): '3*x3 - x1', (1, 3): '-(x1 + 2*x2)', (2, 3): 'x1 + x2 - x3'} >>> # Defines a simple mesh >>> mesh = np.array([[1., 1., 1.]]) >>> # Evaluates the mesh >>> npg3.num_linear_normal_form_R3(bivector, mesh) >>> [[[ 0. -1. -1.] [ 1. 0. 1.] [ 1. -1. 0.]]] >>> npg3.num_linear_normal_form_R3(bivector, mesh, pt_output=True) >>> tensor([[[ 0., -1., -1.], [ 1., 0., 1.], [ 1., -1., 0.]]], dtype=torch.float64) >>> npg3.num_linear_normal_form_R3(bivector, mesh, tf_output=True) >>> tf.Tensor( [[[ 0. -1. -1.] [ 1. 0. 1.] [ 1. -1. 0.]]], shape=(1, 3, 3), dtype=float64) >>> npg3.num_linear_normal_form_R3(bivector, mesh, dict_output=True) """ # Get the lineal normal form from a bivector lin_normal_form = self.pg.linear_normal_form_R3(linear_bivector) # Evaluates the linear normal form from a bivector in each point from mesh and save the result in Numpy array dict_list = dict_mesh_eval(lin_normal_form, mesh, self.pg.coords) np_result = dicts_to_matrices(dict_list, self.pg.dim) # return the result in a PyTorch tensor if the flag is True if pt_output: return torch.from_numpy(np_result) # return the result in a TensorFlow tensor if the flag is True if tf_output: # TODO apply lambdify method to tensorflow return tf.convert_to_tensor(np_result) # return the result in dictionary type if dict_output: return dict_list # return the result in Numpy array return np_result
def num_coboundary_operator(self, bivector, multivector, mesh, tf_output=False, pt_output=False, dict_output=False): """ Evalueates the Schouten-Nijenhuis bracket between a given (Poisson) bivector field and a (arbitrary) multivector field in all points given of a mesh. The Lichnerowicz-Poisson operator is defined as [P,A](df1,...,df(a+1)) = sum_(i=1)^(a+1) (-1)**(i)*{fi,A(df1,...,î,...,df(a+1))}_P + sum(1<=i<j<=a+1) (-1)**(i+j)*A(d{fi,fj}_P,..î..^j..,df(a+1)) where P = Pij*Dxi^Dxj (i < j), A = A^J*Dxj_1^Dxj_2^...^Dxj_a. Parameters ========== :bivector: Is a Poisson bivector in a dictionary format with tuple type 'keys' and string type 'values'. :multivector: Is a multivector filed in a dictionary format with integer type 'keys' and string type 'values'. :mesh: Is a numpy array where each value is a list of float values that representa a point in R^{dim}. :dict_output: Is a boolean flag to indicates if the result is given in a bivector in dictionary format, its default value is False. :pt_output/tf_output: Is a boolean flag to indicates if the result is given in a tensor from PyTorch/TensorFlow, its default value is False. Returns ======= The default result is a NumPy array that contains all the evaluations of the Schouten-Nijenhuis bracket. This value can be converted to Tensor PyTorch, TensorFlow or dictionary for by setting their respective flag as True in the params. Example ======== >>> import numpy as np >>> from poisson import NumPoissonGeometry >>> # Instance the class to dimension 3 >>> npg3 = NumPoissonGeometry(3) >>> # For bivector x3*Dx1^Dx2 - x2*Dx1^Dx3 + x1*Dx2^Dx3 >>> bivector = {(1, 2): 'x3', (1, 3): '-x2', (2, 3): 'x1'} >>> # Defines a one form W >>> W = {(1,): 'x1 * exp(-1/(x1**2 + x2**2 - x3**2)**2) / (x1**2 + x2**2)', (2,): 'x2 * exp(-1/(x1**2 + x2**2 - x3**2)**2) / (x1**2 + x2**2)', (3,): 'exp(-1 / (x1**2 + x2**2 - x3**2)**2)'} >>> mesh = np.array([[0., 0., 1.]]) >>> # Evaluates the mesh into {f,g} >>> npg3.num_coboundary_operator(bivector, multivector, mesh) >>> [[[ 0. , 0.36787945, 0. ], [-0.36787945, 0. , 0. ], [ 0. , 0. , 0. ]]] >>> npg3.num_coboundary_operator(bivector, multivector, mesh, dict_output=True) >>> [{(1, 2): 0.36787944117144233}] >>> npg3.num_coboundary_operator(bivector, multivector, mesh, pt_output=True) >>> tensor([[[ 0.0000, 0.3679, 0.0000], [-0.3679, 0.0000, 0.0000], [ 0.0000, 0.0000, 0.0000]]], dtype=torch.float64) >>> npg3.num_coboundary_operator(bivector, mesh, multivector, tf_output=True) >>> tf.Tensor: shape=(1, 3, 3), dtype=float64, numpy= array([[[ 0. , 0.36787945, 0. ], [-0.36787945, 0. , 0. ], [ 0. , 0. , 0. ]]] """ image_bivector = self.pg.lichnerowicz_poisson_operator( bivector, multivector) dict_eval = dict_mesh_eval(image_bivector, mesh, self.pg.coords) if isinstance(image_bivector, int): np_result = np.array(dict_eval) else: multivector_dim = check_multivector_dim( bivector) + check_multivector_dim(multivector) - 1 # This block creates an evalutes numerically an multivector np_array = [] for item in dict_eval: tensor_base, index_base = create_tensor_base( self.pg.dim, multivector_dim) result = add_tensor_values(item, tensor_base, index_base) np_array.append(result.tolist()) # Add all evaluation in np array np_result = np.array(np_array) # return the result in dictionary type if dict_output: return dict_eval # return the result in a TensorFlow tensor if the flag is True if pt_output: return torch.from_numpy(np_result) # return the result in a PyTorch tensor if the flag is True if tf_output: # TODO apply lambdify method to tensorflow return tf.convert_to_tensor(np_result) # return the result in Numpy array return np_result
def num_curl_operator(self, multivector, function, mesh, tf_output=False, pt_output=False, dict_output=False): """ Evaluates the divergence of multivector field in all points given of a mesh. Parameters ========== :multivector: Is a multivector filed in a dictionary format with integer type 'keys' and string type 'values'. :function: Is a nowhere vanishing function in a string type. If the function is constant you can input the number type. :mesh: Is a numpy array where each value is a list of float values that representa a point in R^{dim}. :dict_output: Is a boolean flag to indicates if the result is given in a bivector in dictionary format, its default value is False. :pt_output/tf_output: Is a boolean flag to indicates if the result is given in a tensor from PyTorch/TensorFlow, its default value is False. Returns ======= The default result is a NumPy array that contains all the evaluations of the divergence of multivertor field in matricial format. This value can be converted to Tensor PyTorch, TensorFlow or dictionary form by setting their respective flag as True in the params. Example ======== >>> import numpy as np >>> from poisson import NumPoissonGeometry >>> # Instance the class to dimension 4 >>> npg4 = NumPoissonGeometry(4) >>> # For bivector 2*x4*Dx1^Dx3 + 2*x3*Dx1^Dx4 - 2*x4*Dx2^Dx3 + 2*x3*Dx2^Dx4 + (x1-x2)*Dx3^Dx4 >>> bivector = {(1, 3): '2*x4', (1, 4): '2*x3', (2, 3): '-2*x4', (2, 4): '2*x3', (3, 4): 'x1 - x2')} >>> mesh = np.array([0., 0., 0. ]) >>> # Evaluates the mesh into {f,g} >>> npg4.num_curl_operator(bivector, function, mesh) >>> [[[ 0.] [ 0.] [ 0.] [ 0.]]]] >>> npg4.num_curl_operator(bivector, function, mesh, dict_output=True) >>> [{0: 0}] >>> npg4.num_curl_operator(bivector, function, mesh, pt_output=True) >>> tensor([[[ 0.], [ 0.], [ 0.], [ 0.]]], dtype=torch.float64) >>> npg4.num_curl_operator(bivector, mesh, function, tf_output=True) >>> tf.Tensor( [[[ 2.5] [-5. ] [ 2.5]]], shape=(1, 3, 1), dtype=float64) """ curl_operator = self.pg.curl_operator(multivector, function) dict_eval = dict_mesh_eval(curl_operator, mesh, self.pg.coords) multivector_dim = check_multivector_dim(multivector) - 1 # This block creates an evalutes numerically an multivector np_array = [] for item in dict_eval: tensor_base, index_base = create_tensor_base( self.pg.dim, multivector_dim) result = add_tensor_values(item, tensor_base, index_base) np_array.append(result.tolist()) # Add all evaluation in np array np_result = np.array(np_array) # return the result in dictionary type if dict_output: return dict_eval # return the result in a PyTorch tensor if the flag is True if pt_output: return torch.from_numpy(np_result) # return the result in a TensorFlow tensor if the flag is True if tf_output: # TODO apply lambdify method to tensorflow return tf.convert_to_tensor(np_result) # return the result in Numpy array return np_result
def num_bivector(self, bivector, mesh, pt_output=False, tf_output=False, dict_output=False): """ Evaluates a bivector field into at each point of the mesh. Parameters ========== :bivector: Is a Poisson bivector in a dictionary format with tuple type 'keys' and string type 'values'. :mesh: Is a numpy array where each value is a list of float values that representa a point in R^{dim}. :pt_out/tf_out: Is a boolean flag to indicates if the result is given in a tensor from PyTorch/TensorFlow, its default value is False. Returns ======= The default result is a NumPy array that contains all the evaluations of a bivector. This value can be converted to Tensor PyTorch or TensorFlow by setting their respective flag as True in the params. Example ======== >>> import numpy as np >>> from poisson import NumPoissonGeometry >>> # Instance the class to dimension 3 >>> npg3 = NumPoissonGeometry(3) >>> # For bivector x3*Dx1^Dx2 - x2*Dx1^Dx3 + x1*Dx2^Dx3 >>> bivector ={(1, 2): ‘x3’, (1, 3): ‘-x2’, (2, 3): ‘x1’} >>> # Creates a simple mesh >>> mesh = np.array([[0., 0., 1.]]) >>> # Evaluates the mesh into bivector >>> npg3.num_bivector(bivector, mesh) >>> [[[ 0. 1. -0.] [-1. 0. 0.] [ 0. -0. 0.]] >>> npg3.num_bivector(bivector, mesh, tf_output=True) >>> tf.Tensor( [[[ 0. 1. -0.] [-1. 0. 0.] [ 0. -0. 0.]]], shape=(1, 3, 3), dtype=float64) >>> npg3.num_bivector(bivector, mesh, pt_output=True) tensor([[[ 0., 1., -0.], [-1., 0., 0.], [ 0., -0., 0.]]], dtype=torch.float64) >>> npg3.num_bivector(bivector, mesh, dict_output=True) >>> [{(1, 2): 1.0, (1, 3): -0.0, (2, 3): 0.0}] """ # Evaluates all point from the mesh in the bivector dict_list = np.array(dict_mesh_eval(bivector, mesh, self.coords)) # save in a np array np_result = dicts_to_matrices(dict_list, self.dim) # return the result in a PyTorch tensor if the flag is True if pt_output: return torch.from_numpy(np_result) # return the result in a TensorFlow tensor if the flag is True if tf_output: # TODO apply lambdify method to tensorflow return tf.convert_to_tensor(np_result) # return the result in dictionary type if dict_output: return dict_list # return the result in Numpy array return np_result