def __div__(self, x, self_on_left=False): """ Division by coefficients. EXAMPLES:: sage: W.<x,y,z> = DifferentialWeylAlgebra(QQ) sage: x / 2 1/2*x sage: W.<x,y,z> = DifferentialWeylAlgebra(ZZ) sage: a = 2*x + 4*y*z sage: a / 2 2*y*z + x """ F = self.parent() D = self.__monomials if F.base_ring().is_field(): x = F.base_ring()(x) x_inv = x**-1 if self_on_left: D = dict_linear_combination([(D, x_inv)], factor_on_left=False) else: D = dict_linear_combination([(D, x_inv)]) return self.__class__(F, D) return self.__class__(F, {t: _divide_if_possible(D[t], x) for t in D})
def __div__(self, x, self_on_left=False): """ Division by coefficients. EXAMPLES:: sage: W.<x,y,z> = DifferentialWeylAlgebra(QQ) sage: x / 2 1/2*x sage: W.<x,y,z> = DifferentialWeylAlgebra(ZZ) sage: a = 2*x + 4*y*z sage: a / 2 2*y*z + x """ F = self.parent() D = self.__monomials if F.base_ring().is_field(): x = F.base_ring()( x ) x_inv = x**-1 if self_on_left: D = dict_linear_combination( [ ( D, x_inv ) ], factor_on_left=False ) else: D = dict_linear_combination( [ ( D, x_inv ) ] ) return self.__class__(F, D) return self.__class__(F, {t: _divide_if_possible(D[t], x) for t in D})
def __init__(self, A, dictionary=None, dual=None): """ Create an element of a dual basis. INPUT: - ``self`` -- an element of the symmetric functions in a dual basis At least one of the following must be specified. The one (if any) which is not provided will be computed. - ``dictionary`` -- an internal dictionary for the monomials and coefficients of ``self`` - ``dual`` -- self as an element of the dual basis. TESTS:: sage: m = SymmetricFunctions(QQ).monomial() sage: zee = sage.combinat.sf.sfa.zee sage: h = m.dual_basis(scalar=zee, prefix='h') sage: a = h([2]) sage: ec = h._element_class sage: ec(h, dual=m([2])) -h[1, 1] + 2*h[2] sage: h(m([2])) -h[1, 1] + 2*h[2] sage: h([2]) h[2] sage: h([2])._dual m[1, 1] + m[2] sage: m(h([2])) m[1, 1] + m[2] """ if dictionary is None and dual is None: raise ValueError, "you must specify either x or dual" parent = A base_ring = parent.base_ring() zero = base_ring(0) if dual is None: #We need to compute the dual dual_dict = {} from_self_cache = parent._from_self_cache #Get the underlying dictionary for self s_mcs = dictionary #Make sure all the conversions from self to #to the dual basis have been precomputed for part in s_mcs: if part not in from_self_cache: parent._precompute(sum(part)) #Create the monomial coefficient dictionary from the #the monomial coefficient dictionary of dual for s_part in s_mcs: from_dictionary = from_self_cache[s_part] for part in from_dictionary: dual_dict[part] = dual_dict.get( part, zero) + base_ring( s_mcs[s_part] * from_dictionary[part]) dual = parent._dual_basis._from_dict(dual_dict) if dictionary is None: #We need to compute the monomial coefficients dictionary dictionary = {} to_self_cache = parent._to_self_cache #Get the underlying dictionary for the #dual d_mcs = dual._monomial_coefficients #Make sure all the conversions from the dual basis #to self have been precomputed for part in d_mcs: if part not in to_self_cache: parent._precompute(sum(part)) #Create the monomial coefficient dictionary from the #the monomial coefficient dictionary of dual dictionary = dict_linear_combination( (to_self_cache[d_part], d_mcs[d_part]) for d_part in d_mcs) #Initialize self self._dual = dual classical.SymmetricFunctionAlgebra_classical.Element.__init__( self, A, dictionary)
def __init__(self, A, dictionary=None, dual=None): """ Create an element of a dual basis. INPUT: - ``self`` -- an element of the symmetric functions in a dual basis At least one of the following must be specified. The one (if any) which is not provided will be computed. - ``dictionary`` -- an internal dictionary for the monomials and coefficients of ``self`` - ``dual`` -- self as an element of the dual basis. TESTS:: sage: m = SymmetricFunctions(QQ).monomial() sage: zee = sage.combinat.sf.sfa.zee sage: h = m.dual_basis(scalar=zee, prefix='h') sage: a = h([2]) sage: ec = h._element_class sage: ec(h, dual=m([2])) -h[1, 1] + 2*h[2] sage: h(m([2])) -h[1, 1] + 2*h[2] sage: h([2]) h[2] sage: h([2])._dual m[1, 1] + m[2] sage: m(h([2])) m[1, 1] + m[2] """ if dictionary is None and dual is None: raise ValueError, "you must specify either x or dual" parent = A base_ring = parent.base_ring() zero = base_ring(0) if dual is None: #We need to compute the dual dual_dict = {} from_self_cache = parent._from_self_cache #Get the underlying dictionary for self s_mcs = dictionary #Make sure all the conversions from self to #to the dual basis have been precomputed for part in s_mcs: if part not in from_self_cache: parent._precompute(sum(part)) #Create the monomial coefficient dictionary from the #the monomial coefficient dictionary of dual for s_part in s_mcs: from_dictionary = from_self_cache[s_part] for part in from_dictionary: dual_dict[ part ] = dual_dict.get(part, zero) + base_ring(s_mcs[s_part]*from_dictionary[part]) dual = parent._dual_basis._from_dict(dual_dict) if dictionary is None: #We need to compute the monomial coefficients dictionary dictionary = {} to_self_cache = parent._to_self_cache #Get the underlying dictionary for the #dual d_mcs = dual._monomial_coefficients #Make sure all the conversions from the dual basis #to self have been precomputed for part in d_mcs: if part not in to_self_cache: parent._precompute(sum(part)) #Create the monomial coefficient dictionary from the #the monomial coefficient dictionary of dual dictionary = dict_linear_combination( (to_self_cache[d_part], d_mcs[d_part]) for d_part in d_mcs) #Initialize self self._dual = dual classical.SymmetricFunctionAlgebra_classical.Element.__init__(self, A, dictionary)