Map initial real root index to an index in a factor where classmethod _reals_index ( reals, index ) # Get real roots of a composite polynomial. Take heroic measures to make poly compatible with CRootOf. Return the root if it is trivial or a CRootOf object. classmethod _postprocess_root ( root, radicals ) # classmethod _new ( poly, index ) #Ĭonstruct new CRootOf object from raw data.
Get a root of a composite polynomial by index. classmethod _indexed_root ( poly, index, lazy = False ) # Return postprocessed roots of specified kind. classmethod _get_roots ( method, poly, radicals ) # Get real root isolating intervals for a square-free factor. classmethod _get_reals_sqf ( currentfactor, use_cache = True ) # classmethod _get_reals ( factors, use_cache = True ) #Ĭompute real root isolating intervals for a list of factors. Internal function for retrieving isolation interval from cache.
Get complex root isolating intervals for a square-free factor. classmethod _get_complexes_sqf ( currentfactor, use_cache = True ) # classmethod _get_complexes ( factors, use_cache = True ) #Ĭompute complex root isolating intervals for a list of factors. _eval_evalf ( prec, ** kwargs ) #Įvaluate this complex root to the given precision. _ensure_reals_init ( ) #Įnsure that our poly has entries in the reals cache. _ensure_complexes_init ( ) #Įnsure that our poly has entries in the complexes cache. classmethod _count_roots ( roots ) #Ĭount the number of real or complex roots with multiplicities. Make complex isolating intervals disjoint and sort roots. classmethod _complexes_sorted ( complexes ) # Map initial complex root index to an index in a factor where classmethod _complexes_index ( complexes, index ) # Get real and complex roots of a composite polynomial. Variables is huge and is given by the following formula if \(M = 0\):Įval_approx, eval_rational classmethod _all_roots ( poly, use_cache = True ) # The total number of monomials in commutative Generate a set of monomials of degree less than or equal to \(N\) and greater Given a set of variables \(V\) and a min_degree \(N\) and a max_degree \(M\) max_degrees And min_degrees Are Both Integers Min_degrees <= degree_list(monom) <= max_degrees,Ĭase I.
Min_degree <= total_degree(monom) <= max_degree,
#Does a polytool break generator#
Unless otherwise specified, min_degrees is either 0 orĪ generator of all monomials monom is returned, such that Max_degrees and min_degrees are either both integers or both lists. itermonomials ( variables, max_degrees, min_degrees = None ) #
as_expr ( * gens ) #Ĭonvert a monomial instance to a SymPy expression. Monomial ( monom, gens = None ) #Ĭlass representing a monomial, i.e. We also show how, by applying program transformations selectively, we obtain abstract machine implementations whose performance can match and even exceed that of highly-tuned, hand-crafted emulators.Domain, Expr Monomials encoded as tuples # class. Thanks to the high level of the language used and its closeness to Prolog the abstract machine descriptions can be manipulated using standard Prolog compilation and optimization techniques with relative ease. These descriptions are then compiled to C and assembled to build a complete bytecode emulator. In this paper we show how the semantics of basic components of an efficient virtual machine for Prolog can be described using (a variant of) Prolog which retains much of its semantics. Writing the abstract machine (and ancillary code) in a higher-level language can help harness this inherent complexity. This is partly due to the fact that efficiency considerations make it necessary to use low-level languages in their implementation. This makes them difficult to code, optimize, and, especially, maintain and extend. Competitive abstract machines for Prolog are usually large, intricate, and incorporate sophisticated optimizations.
0 kommentar(er)
