Coverage for local/lib/python2.7/site-packages/sage/libs/symmetrica/symmetrica.pxi : 73%
Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
|
# We put all definitions together, whether they appear in def.h or # macro.h cdef extern from 'symmetrica/def.h': pass
cdef extern from 'symmetrica/macro.h': ctypedef int INT ctypedef INT OBJECTKIND
cdef struct vector: pass cdef struct bruch: pass cdef struct graph: pass cdef struct list: pass cdef struct matrix: pass cdef struct monom: pass cdef struct number: pass cdef struct partition: pass cdef struct permutation: pass cdef struct reihe: pass cdef struct skewpartition: pass cdef struct symchar: pass cdef struct tableaux: pass
cdef enum: INFREELIST = -1 EMPTY = 0 INTEGER = 1 VECTOR = 2 PARTITION = 3 FRACTION = 4 BRUCH = 4 PERMUTATION = 6 SKEWPARTITION = 7 TABLEAUX = 8 POLYNOM = 9 SCHUR = 10 MATRIX = 11 AUG_PART = 12 HOM_SYM = 13 HOMSYM = 13 SCHUBERT = 14 INTEGERVECTOR = 15 INTEGER_VECTOR = 15 INT_VECTOR = 15 INTVECTOR = 15 KOSTKA = 16 INTINT = 17 SYMCHAR = 18 WORD =19 LIST =20 # 210688 */ MONOM =21 #230688*/ LONGINT =22 # 170888 */ GEN_CHAR =23 # 280888 nur fuer test-zwecke */ BINTREE =24 # 291288 */ GRAPH =25 # 210889 */ COMP =26 # 300889 */ COMPOSITION =26 # 300889 */ KRANZTYPUS =27 # 280390 */ POW_SYM =28 POWSYM =28 MONOMIAL =29 # 090992 */ BTREE =30 KRANZ =31 GRAL =32 # 200691 */ GROUPALGEBRA =32 # 170693 */ ELM_SYM =33 # 090992 */ ELMSYM =33 # 090992 */ FINITEFIELD = 35 # 250193 */ FF = 35 # 250193 */ REIHE = 36 # 090393 */ CHARPARTITION = 37 # 130593 */ # internal use */ CHAR_AUG_PART = 38 # 170593 */ # internal use */ INTEGERMATRIX =40 # AK 141293 */ CYCLOTOMIC = 41 # MD */ MONOPOLY = 42 # MD */ SQ_RADICAL = 43 # MD */ BITVECTOR = 44 LAURENT =45 SUBSET =47 # AK 220997 */ FASTPOLYNOM =211093 EXPONENTPARTITION =240298 SKEWTABLEAUX =20398 PARTTABLEAUX =10398 BARPERM =230695 PERMVECTOR =180998 PERM_VECTOR =180998 PERMUTATIONVECTOR =180998 PERMUTATION_VECTOR =180998 INTEGERBRUCH =220998 INTEGER_BRUCH =220998 INTEGERFRACTION =220998 INTEGER_FRACTION =220998 HASHTABLE =120199
cdef struct loc: INT w2, w1, w0 loc *nloc
cdef struct longint: loc *floc signed char signum #-1,0,+1 INT laenge
ctypedef union OBJECTSELF: INT ob_INT INT *ob_INTpointer char *ob_charpointer bruch *ob_bruch graph *ob_graph list *ob_list longint *ob_longint matrix *ob_matrix monom *ob_monom number *ob_number partition *ob_partition permutation *ob_permutation reihe *ob_reihe skewpartition *ob_skewpartition symchar *ob_symchar tableaux *ob_tableaux vector *ob_vector
cdef struct obj: OBJECTKIND ob_kind OBJECTSELF ob_self
cdef struct ganzdaten: INT basis, basislaenge, auspos, auslaenge, auszz
cdef struct zahldaten: char ziffer[13] INT mehr INT ziffernzhal loc *fdez
ctypedef obj *OP
cdef struct vector: OP v_length OP v_self
cdef struct REIHE_variablen: INT index INT potenz REIHE_variablen *weiter
cdef struct REIHE_mon: OP coeff REIHE_variablen *zeiger REIHE_mon *ref
cdef struct REIHE_poly: INT grad REIHE_mon *uten REIHE_poly *rechts
cdef struct reihe: INT exist INT reihenart INT z reihe *x reihe *y reihe *p INT (*eingabefkt)() char ope REIHE_poly *infozeig
ctypedef reihe* REIHE_ZEIGER
cdef struct list: OP l_self OP l_next
cdef struct partition: OBJECTKIND pa_kind OP pa_self
cdef struct permutation: OBJECTKIND p_kind OP p_self
cdef struct monom: OP mo_self OP mo_koeff
cdef struct bruch: OP b_oben OP b_uten INT b_info
cdef struct matrix: OP m_length OP m_height OP m_self
cdef struct skewpartition: OP spa_gross OP spa_klein
cdef struct tableaux: OP t_umriss OP t_self
cdef struct symchar: OP sy_werte OP sy_parlist OP sy_dimension
cdef struct graph: OBJECTKIND gr_kind OP gr_self
cdef struct CYCLO_DATA: OP index, deg, poly, autos
cdef struct FIELD_DATA: OP index, deg, poly
ctypedef union data: CYCLO_DATA *c_data FIELD_DATA *f_data OP o_data
cdef struct number: OP n_self data n_data
#MACROS #S_PA_I(OP a, INT i) OBJECTKIND s_o_k(OP a) void* c_o_k(OP a, OBJECTKIND k) OBJECTSELF S_O_S(OP a)
void* add(OP a, OP b, OP c) void* mult(OP a, OP b, OP c) void* sub(OP a, OP b, OP c)
#Integers void* m_i_i(INT n, OP a) void* M_I_I(INT n, OP a) INT S_I_I(OP a) t_int_longint(OP a, OP b) void* m_i_longint(INT n, OP a)
#Fractions OP S_B_O(OP a) OP S_B_U(OP a) OP m_ou_b(OP o, OP u, OP d)
#Vectors void* M_IL_V(INT length, OP a) void* m_il_v(INT n, OP a ) void* m_i_i(INT n, OP a)
INT s_v_li(OP a) OP s_v_i(OP a, INT i)
#Partitions OP s_pa_l(OP a) INT s_pa_li(OP a) INT s_pa_ii(OP a, INT i) OP s_pa_i(OP a, INT i) OP S_PA_S(OP a) OP S_PA_I(OP a, INT ) void* b_ks_pa(INT kind, OP b, OP a)
#Skew Partitions INT b_gk_spa(OP gross, OP klein, OP result) INT m_gk_spa(OP gross, OP klein, OP result) OP s_spa_g(OP spa) OP s_spa_k(OP spa)
#Permutations OP s_p_i(OP a, INT i) INT s_p_li(OP a) INT s_p_ii(OP a, INT i) void* m_il_p(INT n, OP a)
#Barred Permutations
#Lists OP s_l_s(OP a) OP S_L_S(OP a) OP s_l_n(OP a) INT lastp_list(OP l) INT empty_listp(OP l)
#Matrices INT S_M_HI(OP a) INT S_M_LI(OP a) OP S_M_IJ(OP a, INT i, INT j) void* m_ilih_m(INT l, INT h, OP a)
#Schur polynomials OP s_s_s(OP a) OP s_s_k(OP a) OP s_s_n(OP a) void* m_skn_s(OP part, OP koeff, OP next, OP result) void* b_skn_s(OP part, OP koeff, OP next, OP result)
#Schubert polynomials OP s_sch_s(OP a) OP s_sch_k(OP a) OP s_sch_n(OP a) void* m_skn_sch(OP perm, OP koeff, OP next, OP result) void* b_skn_sch(OP perm, OP koeff, OP next, OP result)
#Polynomials OP s_po_n(OP a) OP s_po_sl(OP a) OP s_po_k(OP a) OP s_po_s(OP a) void* m_skn_po(OP s, OP k, OP next, OP polynom)
#Tableaux OP S_T_S(OP t)
#########
INT insert(OP a, OP b, INT (*eq)(), INT (*comp)())
INT nullp_sqrad(OP a) OP S_PO_K(OP a) OP S_PO_S(OP a) OP S_L_N(OP a) OP S_N_S(OP a) INT einsp(OP A)
#Empty Object int EMPTYP(OP obj)
#Functions INT anfang() INT ende() OP callocobject() INT sscan(INT, OP a) INT scan(INT, OP a) INT freeall(OP a) INT freeself(OP a) INT sprint(char* t, OP a) INT sprint_integer(char* t, OP A) INT println(OP a)
#factorial INT fakul(OP a, OP b)
########################################## cdef object matrix_constructor cdef object Integer cdef object Tableau, SkewTableau cdef object SkewPartition cdef object Partition cdef object Permutation, Permutations cdef object builtinlist cdef object sqrt cdef object Rational cdef object QQ cdef object ZZ cdef object SymmetricFunctions cdef object PolynomialRing cdef object SchubertPolynomialRing, SchubertPolynomial_class cdef object two, fifteen, thirty, zero, sage_maxint
cdef int maxint = 2147483647
cdef void late_import(): global matrix_constructor, \ Integer, \ Tableau, \ SkewTableau, \ SkewPartition, \ Partition, \ Permutation, Permutations,\ prod, \ PolynomialRing, \ Rational, \ QQ, \ ZZ, \ SymmetricFunctions, \ sqrt, \ builtinlist, \ MPolynomialRing_generic, is_MPolynomial,\ SchubertPolynomialRing, SchubertPolynomial_class,\ two, fifteen, thirty, zero, sage_maxint
#Symmetric Functions
########################################## cdef object _py(OP a): cdef OBJECTKIND objk elif objk == LONGINT: elif objk == PARTITION: return _py_partition(a) elif objk == PERMUTATION: elif objk == SKEWPARTITION: return _py_skew_partition(a) elif objk == FRACTION: elif objk == SQ_RADICAL: return _py_sq_radical(a) elif objk == MATRIX or objk == KRANZTYPUS: elif objk == SCHUR: elif objk == HOMSYM: elif objk == POWSYM: elif objk == ELMSYM: elif objk == MONOMIAL: elif objk == LIST: elif objk == VECTOR: elif objk == TABLEAUX: elif objk == EMPTY: return None elif objk == POLYNOM: elif objk == SCHUBERT: else: #println(a) raise NotImplementedError(str(objk))
cdef int _op(object a, OP result) except -1: _op_partition(a, result) else: raise TypeError("cannot convert a (= %s) to OP" % a)
def test_integer(object x): """ Tests functionality for converting between Sage's integers and symmetrica's integers.
EXAMPLES::
sage: from sage.libs.symmetrica.symmetrica import test_integer sage: test_integer(1) 1 sage: test_integer(-1) -1 sage: test_integer(2^33) 8589934592 sage: test_integer(-2^33) -8589934592 sage: test_integer(2^100) 1267650600228229401496703205376 sage: test_integer(-2^100) -1267650600228229401496703205376 sage: for i in range(100): ....: if test_integer(2^i) != 2^i: ....: print("Failure at {}".format(i)) """
########## #Integers# ##########
cdef int _op_integer(object x, OP a) except -1:
cdef int _op_int(object x, OP a) except -1:
cdef object _py_int(OP a):
cdef int _op_longint(object x, OP a) except -1:
#Multiply a by op_maxint_long
#Add rem to a
cdef object _py_longint(OP a):
########### #Fractions# ########### cdef object _py_fraction(OP a):
cdef int _op_fraction(object f, OP a) except -1:
######### #Vectors# ######### cdef object _py_vector(OP a): cdef INT i
cdef void* _op_il_vector(object l, OP a): cdef INT length, i
######### #Numbers# ######### cdef object _py_sq_radical(OP a): late_import()
cdef OP ptr ptr = S_N_S(a)
res = 0 if nullp_sqrad(a): return res
while ptr != NULL:
if einsp(S_PO_S(ptr)): res += _py(S_PO_K(ptr)) else: res += _py(S_PO_K(ptr))*sqrt(_py(S_PO_S(ptr)))
ptr = S_L_N(ptr);
return res.radical_simplify()
############ #Partitions# ############ cdef void* _op_partition(object p, OP a): cdef int n, i, j
freeself(a)
cdef object _py_partition(OP a): cdef INT n, i
################ #Skew Partition# ################ cdef void* _op_skew_partition(object p, OP a): cdef OP gross, klein
#print p[0], p[1]
cdef object _py_skew_partition(OP a): late_import() return SkewPartition( [ _py_partition(s_spa_g(a)), _py_partition(s_spa_k(a)) ] )
############## #Permutations# ############## cdef void* _op_permutation(object p, OP a): cdef int n, i, j
freeself(a)
cdef object _py_permutation(OP a): cdef INT n, i
##################### #Barred Permutations# #####################
####### #Lists# ####### cdef object _py_list(OP a): cdef OP x return []
############# #Polynomials# ############# cdef object _py_polynom(OP a):
return 0
#Find the maximum number of variables needed
else:
cdef object _py_polynom_alphabet(OP a, object alphabet, object length): """ Converts a symmetrica multivariate polynomial a to a Sage multivariate polynomials. Alphabet specifies the names of the variables which are fed into PolynomialRing. length specifies the number of variables; if it is set to 0, then the number of variables is autodetected based on the number of variables in alphabet or the result obtained from symmetrica.
"""
return 0
if isinstance(alphabet, (builtinlist, tuple)): l = len(alphabet) elif isinstance(alphabet, str) and ',' in alphabet: l = len(alphabet.split(',')) else: l = _py(s_po_sl(a)) else:
cdef object _op_polynom(object d, OP res):
raise TypeError("you must pass a multivariate polynomial")
raise TypeError("the base ring must be either ZZ or QQ")
cdef int n, i
m_skn_po(v,c, callocobject(), pointer) else:
####################################### #Schur symmetric functions and friends# ####################################### cdef object _py_schur(OP a): return SymmetricFunctions(ZZ).s()(0)
#Figure out the parent ring of a coefficient
cdef void* _op_schur(object d, OP res):
cdef object _py_monomial(OP a): #Monomial symmetric functions return SymmetricFunctions(ZZ).m()(0)
cdef void* _op_monomial(object d, OP res): #Monomial symmetric functions
cdef object _py_powsym(OP a): #Power-sum symmetric functions return SymmetricFunctions(ZZ).p()(0)
cdef void* _op_powsym(object d, OP res): #Power-sum symmetric functions
cdef object _py_elmsym(OP a): #Elementary symmetric functions return SymmetricFunctions(ZZ).e()(0)
cdef void* _op_elmsym(object d, OP res): #Elementary symmetric functions
cdef object _py_homsym(OP a): #Homogenous symmetric functions return SymmetricFunctions(ZZ).h()(0)
cdef void* _op_homsym(object d, OP res): #Homogenous symmetric functions
cdef object _py_schur_general(OP a): return d
cdef void* _op_schur_general(object d, OP res): else:
cdef void* _op_schur_general_sf(object f, OP res): raise ValueError("the base ring must be either ZZ or QQ")
cdef void* _op_schur_general_dict(object d, OP res):
cdef OP next cdef INT n, i
raise ValueError("the dictionary must be nonempty")
next = callocobject()
b_skn_s(callocobject(), callocobject(), NULL, next) _op_partition(keys[i], s_s_s(next)) _op(d[keys[i]], s_s_k(next))
insert(next, res, NULL, NULL)
###################### #Schubert Polynomials# ###################### cdef void* _op_schubert_general(object d, OP res): if isinstance(d, dict): _op_schubert_dict(d, res) else: _op_schubert_sp(d, res)
cdef void* _op_schubert_perm(object a, OP res):
cdef void* _op_schubert_sp(object f, OP res): raise ValueError("the base ring must be either ZZ or QQ")
cdef void* _op_schubert_dict(object d, OP res):
cdef OP next cdef INT n, i
raise ValueError("the dictionary must be nonempty")
next = callocobject()
b_skn_sch(callocobject(), callocobject(), NULL, next) _op_permutation(keys[i], s_sch_s(next)) _op(d[keys[i]], s_sch_k(next))
insert(next, res, NULL, NULL)
cdef object _py_schubert(OP a):
# SCHUBERT is (like) a list, so we also need to make sure it is not empty return SchubertPolynomialRing(ZZ).zero()
return SchubertPolynomialRing(ZZ).zero()
# If the element constructor ends up copying the input dict in the future, # then this will not be as fast as creating a copy of the zero element # and explicitly setting the _monomial_coefficients.
########## #Matrices# ########## cdef object _py_matrix(OP a):
cdef INT i,j,rows, cols
#return res return res else:
cdef void* _op_matrix(object a, OP res): #FIXME: only constructs integer matrices
cdef INT i,j,rows, cols
rows = a.nrows() cols = a.ncols()
m_ilih_m(rows, cols, res)
for i from 0 <= i < rows: for j from 0 <= j < cols: _op_integer( a[(i,j)], S_M_IJ(res,i,j) )
########## #Tableaux# ########## cdef object _py_tableau(OP t):
cdef OP a
else: else:
#return res else:
def start(): anfang()
def end(): ende() |