hash stringlengths 64 64 | content stringlengths 0 1.51M |
|---|---|
e237ebcc094016bed923a2fe1d6e4164accb4e01b0abca4bacb219c384031f8a | """ Caching facility for SymPy """
from __future__ import print_function, division
from distutils.version import LooseVersion as V
class _cache(list):
""" List of cached functions """
def print_cache(self):
"""print cache info"""
for item in self:
name = item.__name__
... |
ca80318f62ce5e0d35b941e3914362bda3a076701b79f1fbef146d9896a6fbbf | """Module for SymPy containers
(SymPy objects that store other SymPy objects)
The containers implemented in this module are subclassed to Basic.
They are supposed to work seamlessly within the SymPy framework.
"""
from __future__ import print_function, division
from collections import OrderedDict
from ... |
59d5ef293b11f4f171c82a601d7add09410ad9789b756a141b7ef84f66ad94a7 | """Logic expressions handling
NOTE
----
at present this is mainly needed for facts.py , feel free however to improve
this stuff for general purpose.
"""
from __future__ import print_function, division
from typing import Dict, Type, Union
# Type of a fuzzy bool
FuzzyBool = Union[bool, None]
def _torf(args):
"... |
39cc73377f8345f5164c893647ad99a84d2c07eb78cd9ca5ea032237a1ef9e76 | from __future__ import print_function, division
from collections import defaultdict
from functools import cmp_to_key
import operator
from .sympify import sympify
from .basic import Basic
from .singleton import S
from .operations import AssocOp
from .cache import cacheit
from .logic import fuzzy_not, _fuzzy_group
from... |
e27b9b213529f2e1607a864132fb69e9931ff56419774b5e8e55ed4fea521f6c | """Tools for setting up printing in interactive sessions. """
from __future__ import print_function, division
import sys
from distutils.version import LooseVersion as V
from io import BytesIO
from sympy import latex as default_latex
from sympy import preview
from sympy.utilities.misc import debug
def _init_python_... |
e4025b99cdc81855c907ffe88a211285081dbf28a3aca7666df8f0a31dd66b5f | from __future__ import print_function
from sympy.matrices.dense import MutableDenseMatrix
from sympy.polys.polytools import Poly
from sympy.polys.domains import EX
class MutablePolyDenseMatrix(MutableDenseMatrix):
"""
A mutable matrix of objects from poly module or to operate with them.
Examples
==... |
69316b6202f94c610c5bda0d1d6826b082cfbacd7e1c4292d769b9903036ec8c | """Definitions of monomial orderings. """
from __future__ import print_function, division
from typing import Optional
__all__ = ["lex", "grlex", "grevlex", "ilex", "igrlex", "igrevlex"]
from sympy.core import Symbol
from sympy.core.compatibility import iterable
class MonomialOrder(object):
"""Base class for mo... |
aea255ba0dd1c8e3aaf4775a6f776f1712092cd4689fe928137a98d4e594c641 | """Power series evaluation and manipulation using sparse Polynomials
Implementing a new function
---------------------------
There are a few things to be kept in mind when adding a new function here::
- The implementation should work on all possible input domains/rings.
Special cases include the ``EX`` rin... |
d482a05ab18fa8641a1f2a1ff1e54508d903f96f43b1f7dc789b681086c3db38 | """OO layer for several polynomial representations. """
from __future__ import print_function, division
from sympy import oo
from sympy.core.sympify import CantSympify
from sympy.polys.polyerrors import CoercionFailed, NotReversible, NotInvertible
from sympy.polys.polyutils import PicklableWithSlots
class GenericPo... |
6545882b79159cde3a0f15be5ad45aa150e5d016110fa226b4e46d00f5860e93 | """Implementation of RootOf class and related tools. """
from __future__ import print_function, division
from sympy.core import (S, Expr, Integer, Float, I, oo, Add, Lambda,
symbols, sympify, Rational, Dummy)
from sympy.core.cache import cacheit
from sympy.core.compatibility import ordered
from sympy.polys.domain... |
5136457609ff65fa791917855cecf1f0830fb3bb6e18fc676a5e96119a1202c3 | """Advanced tools for dense recursive polynomials in ``K[x]`` or ``K[X]``. """
from __future__ import print_function, division
from sympy.polys.densearith import (
dup_add_term, dmp_add_term,
dup_lshift,
dup_add, dmp_add,
dup_sub, dmp_sub,
dup_mul, dmp_mul,
dup_sqr,
dup_div,
dup_rem, d... |
ee82a3c2b4af445260dcc58b94861294dd1fdc927cc6934639310a66ff6ae080 | """User-friendly public interface to polynomial functions. """
from __future__ import print_function, division
from functools import wraps
from sympy.core import (
S, Basic, Expr, I, Integer, Add, Mul, Dummy, Tuple
)
from sympy.core.basic import preorder_traversal
from sympy.core.compatibility import iterable, o... |
f11233af8a86ed62ccf451f574e917c3b44208c4e1d0563bab8ce24b17c13bbb | """Functions for generating interesting polynomials, e.g. for benchmarking. """
from __future__ import print_function, division
from sympy.core import Add, Mul, Symbol, sympify, Dummy, symbols
from sympy.core.containers import Tuple
from sympy.core.singleton import S
from sympy.functions.elementary.miscellaneous impo... |
e110e9a13ac140ce264f36471bbe64d5a91b50c18102d39869cf3efa40b8c6c2 | """Implementation of matrix FGLM Groebner basis conversion algorithm. """
from __future__ import print_function, division
from sympy.polys.monomials import monomial_mul, monomial_div
def matrix_fglm(F, ring, O_to):
"""
Converts the reduced Groebner basis ``F`` of a zero-dimensional
ideal w.r.t. ``O_from`... |
e51be85113a46aacaffcc079d1ed9801b39255fe4ede9dcbd4f45c7e71f5a86b | """Basic tools for dense recursive polynomials in ``K[x]`` or ``K[X]``. """
from __future__ import print_function, division
from sympy import oo
from sympy.core import igcd
from sympy.polys.monomials import monomial_min, monomial_div
from sympy.polys.orderings import monomial_key
import random
def poly_LC(f, K):
... |
2a6e08e44f8208533900c2d82a82798e9ba83908e6eeb291e8a9010a20c637fd | """Algorithms for computing symbolic roots of polynomials. """
from __future__ import print_function, division
import math
from sympy.core import S, I, pi
from sympy.core.compatibility import ordered, reduce
from sympy.core.exprtools import factor_terms
from sympy.core.function import _mexpand
from sympy.core.logic ... |
57f46b674d15cdff43242633938de19ef635fe683ea27b95c6d8f91483109165 | """Arithmetics for dense recursive polynomials in ``K[x]`` or ``K[X]``. """
from __future__ import print_function, division
from sympy.polys.densebasic import (
dup_slice,
dup_LC, dmp_LC,
dup_degree, dmp_degree,
dup_strip, dmp_strip,
dmp_zero_p, dmp_zero,
dmp_one_p, dmp_one,
dmp_ground, dm... |
ba48dc1290b99adbcc095143d1a25fe785d0abf05ebd4322667a8d378b701a49 | """Dense univariate polynomials with coefficients in Galois fields. """
from __future__ import print_function, division
from random import uniform
from math import ceil as _ceil, sqrt as _sqrt
from sympy.core.compatibility import SYMPY_INTS
from sympy.core.mul import prod
from sympy.ntheory import factorint
from sym... |
816293327def1086d72f39c031e1cd50a42d9b0b7f6dc9cba30ba194ffe3e533 | """
This module contains functions for the computation
of Euclidean, (generalized) Sturmian, (modified) subresultant
polynomial remainder sequences (prs's) of two polynomials;
included are also three functions for the computation of the
resultant of two polynomials.
Except for the function res_z(), which computes the ... |
8529e951df967725efc1a46e317e49cec68624b0197850d56c5305ed6cb091c4 | """Sparse polynomial rings. """
from __future__ import print_function, division
from typing import Any, Dict
from operator import add, mul, lt, le, gt, ge
from types import GeneratorType
from sympy.core.compatibility import is_sequence, reduce
from sympy.core.expr import Expr
from sympy.core.numbers import igcd, oo... |
e6cd48fe20fe2ae35a2b8435537eeeffbc7aeeef72e67e3e7d0f1d803dba477f | """Options manager for :class:`~.Poly` and public API functions. """
from __future__ import print_function, division
__all__ = ["Options"]
from typing import Dict, List, Optional, Type
from sympy.core import S, Basic, sympify
from sympy.polys.polyerrors import GeneratorsError, OptionError, FlagError
from sympy.util... |
4fd42e3b11f4906e77b74a5c8b27aeb575dff8b80c75489ddcd90f477f31b34c | """Groebner bases algorithms. """
from __future__ import print_function, division
from sympy.core.symbol import Dummy
from sympy.polys.monomials import monomial_mul, monomial_lcm, monomial_divides, term_div
from sympy.polys.orderings import lex
from sympy.polys.polyerrors import DomainError
from sympy.polys.polyconfi... |
194575a148b43f3e1ab89c7b37a78c476132696b1139b956808ff80f22fe9db8 | from sympy import Dummy
from sympy.ntheory import nextprime
from sympy.ntheory.modular import crt
from sympy.polys.domains import PolynomialRing
from sympy.polys.galoistools import (
gf_gcd, gf_from_dict, gf_gcdex, gf_div, gf_lcm)
from sympy.polys.polyerrors import ModularGCDFailed
from mpmath import sqrt
import r... |
859d023461857019763af76aeba102307b1368988e7a95795ad1111163d3bfa9 | """High-level polynomials manipulation functions. """
from __future__ import print_function, division
from sympy.core import S, Basic, Add, Mul, symbols, Dummy
from sympy.polys.polyerrors import (
PolificationFailed, ComputationFailed,
MultivariatePolynomialError, OptionError)
from sympy.polys.polyoptions imp... |
418c6facbc005d4e511538b950d5fc0109b158215d69e4f3d8de28ed39e5eac4 | """Heuristic polynomial GCD algorithm (HEUGCD). """
from __future__ import print_function, division
from .polyerrors import HeuristicGCDFailed
HEU_GCD_MAX = 6
def heugcd(f, g):
"""
Heuristic polynomial GCD in ``Z[X]``.
Given univariate polynomials ``f`` and ``g`` in ``Z[X]``, returns
their GCD and c... |
f4cd594976acda095028b1cdef0a0eeaaff632f74eebfab8ec539c5a4ac4680c | """Tools and arithmetics for monomials of distributed polynomials. """
from __future__ import print_function, division
from itertools import combinations_with_replacement, product
from textwrap import dedent
from sympy.core import Mul, S, Tuple, sympify
from sympy.core.compatibility import exec_, iterable
from sympy... |
0107c7e27934ea832e17ce77ef9fa840a65d61e5f2c2ea96c324a54615aca318 | """Sparse rational function fields. """
from __future__ import print_function, division
from typing import Any, Dict
from operator import add, mul, lt, le, gt, ge
from sympy.core.compatibility import is_sequence, reduce
from sympy.core.expr import Expr
from sympy.core.mod import Mod
from sympy.core.numbers import E... |
02b061bc2606a0cc177ee6d93b0eae49533b53a9af92b6bd8891735cc84bc78f | """Low-level linear systems solver. """
from __future__ import print_function, division
from sympy.matrices import MutableDenseMatrix, zeros
class RawMatrix(MutableDenseMatrix):
_sympify = staticmethod(lambda x: x)
def eqs_to_matrix(eqs, ring):
"""Transform from equations to matrix form. """
xs = ring.g... |
c21463f55f84e1dd7b17ab3e6d2478d753debea7de3f6556e91a521f53a915d2 | """Algorithms for partial fraction decomposition of rational functions. """
from __future__ import print_function, division
from sympy.core import S, Add, sympify, Function, Lambda, Dummy
from sympy.core.basic import preorder_traversal
from sympy.polys import Poly, RootSum, cancel, factor
from sympy.polys.polyerrors ... |
f1e6edf71be79ea41ab2447d080562181f9c46329d1fc324a937d9f84d50524d | """Real and complex root isolation and refinement algorithms. """
from __future__ import print_function, division
from sympy.polys.densearith import (
dup_neg, dup_rshift, dup_rem)
from sympy.polys.densebasic import (
dup_LC, dup_TC, dup_degree,
dup_strip, dup_reverse,
dup_convert,
dup_terms_gcd)
... |
c37e184652a0d88ae242e3e5af1d9f770df0a8eb200fa12350b0c246b2936f9d | """Efficient functions for generating orthogonal polynomials. """
from __future__ import print_function, division
from sympy import Dummy
from sympy.polys.constructor import construct_domain
from sympy.polys.densearith import (
dup_mul, dup_mul_ground, dup_lshift, dup_sub, dup_add
)
from sympy.polys.domains impor... |
62d9dfb243a900522e1ab9d0a86fabb606acec6686551a3c2e19776453f4dba5 | """
This module contains functions for two multivariate resultants. These
are:
- Dixon's resultant.
- Macaulay's resultant.
Multivariate resultants are used to identify whether a multivariate
system has common roots. That is when the resultant is equal to zero.
"""
from sympy import IndexedBase, Matrix, Mul, Poly
fr... |
ea18651e4de7d7aa388140502514662ad481ea6a1d11bc3bb2a282307da1172c | """Useful utilities for higher level polynomial classes. """
from __future__ import print_function, division
from sympy.core import (S, Add, Mul, Pow, Eq, Expr,
expand_mul, expand_multinomial)
from sympy.core.exprtools import decompose_power, decompose_power_rat
from sympy.polys.polyerrors import PolynomialError,... |
cddd45209b4a3869b6061e4a93181de95a8c0ada4e0585d9df5f3c2b4954e730 | """Computational algebraic field theory. """
from __future__ import print_function, division
from sympy import (
S, Rational, AlgebraicNumber, GoldenRatio, TribonacciConstant,
Add, Mul, sympify, Dummy, expand_mul, I, pi
)
from sympy.functions import sqrt, cbrt
from sympy.core.compatibility import reduce
from ... |
f4cc6c1ce1a4941a0cb50e2650160a8878d015f0b18602e2798e0bd84153f7e4 | """Euclidean algorithms, GCDs, LCMs and polynomial remainder sequences. """
from __future__ import print_function, division
from sympy.ntheory import nextprime
from sympy.polys.densearith import (
dup_sub_mul,
dup_neg, dmp_neg,
dmp_add,
dmp_sub,
dup_mul, dmp_mul,
dmp_pow,
dup_div, dmp_div,... |
23b2aa01b16446a20ee4bf685aa7e9b7f0bc84cee6aea985b35c8ba96323d182 | """Polynomial factorization routines in characteristic zero. """
from __future__ import print_function, division
from sympy.polys.galoistools import (
gf_from_int_poly, gf_to_int_poly,
gf_lshift, gf_add_mul, gf_mul,
gf_div, gf_rem,
gf_gcdex,
gf_sqf_p,
gf_factor_sqf, gf_factor)
from sympy.poly... |
6eb7476df6564b27a79f776ac87512061ae973482ee15ab785cc3899d6e9a7eb | r"""
Sparse distributed elements of free modules over multivariate (generalized)
polynomial rings.
This code and its data structures are very much like the distributed
polynomials, except that the first "exponent" of the monomial is
a module generator index. That is, the multi-exponent ``(i, e_1, ..., e_n)``
represent... |
f4454d95f6769f3ec9e4f9d209d4f35a0a792ff7682063caf6a229c7ec8817be | """ Generic Unification algorithm for expression trees with lists of children
This implementation is a direct translation of
Artificial Intelligence: A Modern Approach by Stuart Russel and Peter Norvig
Second edition, section 9.2, page 276
It is modified in the following ways:
1. We allow associative and commutati... |
0f8a1382ff9daaac01a6bcfd22950d9654e19d9211a5b87fdc187b6576c7c889 | """py.test hacks to support XFAIL/XPASS"""
from __future__ import print_function, division
import sys
import functools
import os
import contextlib
import warnings
from sympy.core.compatibility import get_function_name
from sympy.utilities.exceptions import SymPyDeprecationWarning
ON_TRAVIS = os.getenv('TRAVIS_BUILD... |
62174cf3b29fb1c8bcdf8d0798aad7566038cb4cff55e50de5041bc003af11b8 | """This module contains code for running the tests in SymPy.
"""
from .runtests import test, doctest
__all__ = [
'test', 'doctest',
]
|
d0ad15c75ae624414877aaffb37162454d7bf186ff03abede8d78bd07733bc98 | """benchmarking through py.test"""
from __future__ import print_function, division
import py
from py.__.test.item import Item
from py.__.test.terminal.terminal import TerminalSession
from math import ceil as _ceil, floor as _floor, log10
import timeit
from inspect import getsource
from sympy.core.compatibility imp... |
c8a6b48fbb99200698d6ef96a135b8c04b30b45d970efd0ec02ad71834e13310 | import re
import fnmatch
# XXX Python 2 unicode import test.
# May remove after deprecating python 2.7.
message_unicode_A = \
"File contains a unicode character : %s, line %s. " \
"But with no encoding header. " \
"See https://www.python.org/dev/peps/pep-0263/ " \
"and add '# coding=utf-8'"
message_un... |
a8a311e8300fa4d626ee555330d7b150b0a9ce92dfe24ec6efe5086719988a69 | """
This is our testing framework.
Goals:
* it should be compatible with py.test and operate very similarly
(or identically)
* doesn't require any external dependencies
* preferably all the functionality should be in this file only
* no magic, just import the test file and execute the test functions, that's it
* po... |
dfb9a8f205625b804a7832f539809737202d1543a7cac2b9391bf8399a9aaa79 | """ Helpers for randomized testing """
from __future__ import print_function, division
from random import uniform, Random, randrange, randint
from sympy.core.compatibility import is_sequence, as_int
from sympy.core.containers import Tuple
from sympy.core.numbers import comp, I
from sympy.core.symbol import Symbol
fr... |
2984af4e928e137bf14b09e1e3d7f5811199c50e9089ce0f5f9bfb5aab19c7da | from sympy.core.basic import Basic
from sympy import (sympify, eye, sin, cos, rot_axis1, rot_axis2,
rot_axis3, ImmutableMatrix as Matrix, Symbol)
from sympy.core.cache import cacheit
import sympy.vector
class Orienter(Basic):
"""
Super-class for all orienter classes.
"""
def rotati... |
eed7238de4947fd5d9e6e34e1b4c53945f61bcbd8f4971a46f5c56dfcb3a2c68 | from sympy.utilities.exceptions import SymPyDeprecationWarning
from sympy.core.basic import Basic
from sympy.core.compatibility import Callable
from sympy.core.cache import cacheit
from sympy.core import S, Dummy, Lambda
from sympy import symbols, MatrixBase, ImmutableDenseMatrix
from sympy.solvers import solve
from sy... |
6f981b194f4edda082b53bd63c8011479c547bea3077d43b387b9d22725e5de0 | from sympy.vector.coordsysrect import CoordSys3D, CoordSysCartesian
from sympy.vector.vector import (Vector, VectorAdd, VectorMul,
BaseVector, VectorZero, Cross, Dot, cross, dot)
from sympy.vector.dyadic import (Dyadic, DyadicAdd, DyadicMul,
BaseDyadic, ... |
7811f27b20cc6dad313cde47533f5f0f528da1171859e935126be705a0128a36 | from typing import Any, Dict
from sympy.simplify import simplify as simp, trigsimp as tsimp
from sympy.core.decorators import call_highest_priority, _sympifyit
from sympy.core.assumptions import StdFactKB
from sympy import factor as fctr, diff as df, Integral
from sympy.core import S, Add, Mul
from sympy.core.expr imp... |
f4215f323c9567ee2d409a3b097b32da723eaaffa91d16198817f4a44467ea99 | from typing import Type
from sympy.core.assumptions import StdFactKB
from sympy.core import S, Pow, sympify
from sympy.core.expr import AtomicExpr, Expr
from sympy.core.compatibility import default_sort_key
from sympy import sqrt, ImmutableMatrix as Matrix, Add
from sympy.vector.coordsysrect import CoordSys3D
from sym... |
857d99d28f731c95fc83cca3f44b859fb02b098c678518b33484d661ed6e0840 | from sympy.core.basic import Basic
from sympy.vector.vector import Vector
from sympy.vector.coordsysrect import CoordSys3D
from sympy.vector.functions import _path
from sympy import Symbol
from sympy.core.cache import cacheit
class Point(Basic):
"""
Represents a point in 3-D space.
"""
def __new__(cl... |
574af5bebbc088426869f40267f1b043ddc53ceca33e1a85be42e495a322aa37 | from sympy.core import AtomicExpr, Symbol, S
from sympy.core.sympify import _sympify
from sympy.printing.pretty.stringpict import prettyForm
from sympy.printing.precedence import PRECEDENCE
class BaseScalar(AtomicExpr):
"""
A coordinate symbol/base scalar.
Ideally, users should not instantiate this class... |
f7f69429700de127fd3a4ff3a35ece625ffce45100cf58574ca0caa4fd6cb472 | from typing import Type
from sympy.vector.basisdependent import (BasisDependent, BasisDependentAdd,
BasisDependentMul, BasisDependentZero)
from sympy.core import S, Pow
from sympy.core.expr import AtomicExpr
from sympy import ImmutableMatrix as Matrix
import sympy.vector
clas... |
1ce70f0a0c6f237624921c9f23d8b0b9140ce690fbed6e0d07f9391480d0283c | """Parabolic geometrical entity.
Contains
* Parabola
"""
from __future__ import division, print_function
from sympy.core import S
from sympy.core.compatibility import ordered
from sympy.core.symbol import _symbol
from sympy import symbols, simplify, solve # type:ignore
from sympy.geometry.entity import GeometryEnti... |
90b75c09fcd2422b8dc49e04cf8ae1c92603022389b3b8a63d1eb59b9c4a3f2c | """Curves in 2-dimensional Euclidean space.
Contains
========
Curve
"""
from __future__ import division, print_function
from sympy import sqrt
from sympy.core import sympify, diff
from sympy.core.compatibility import is_sequence
from sympy.core.containers import Tuple
from sympy.core.symbol import _symbol
from symp... |
701a55a3df8b677ab45a244e91fdd17f242bb5e6e05c34da8d6e47c83ba920fa | """Geometrical Planes.
Contains
========
Plane
"""
from __future__ import division, print_function
from sympy import simplify # type:ignore
from sympy.core import Dummy, Rational, S, Symbol
from sympy.core.symbol import _symbol
from sympy.core.compatibility import is_sequence
from sympy.functions.elementary.trigono... |
ec924c1edcce7f7b35e3ea718eb6aba7bd5c30b7c061d87097e58c480637bd1e | """The definition of the base geometrical entity with attributes common to
all derived geometrical entities.
Contains
========
GeometryEntity
GeometricSet
Notes
=====
A GeometryEntity is any object that has special geometric properties.
A GeometrySet is a superclass of any GeometryEntity that can also
be viewed as ... |
c9edf1826d14602d286c3afaf1b771ded2c2452b773307693c4197e6e46f9f36 | """Utility functions for geometrical entities.
Contains
========
intersection
convex_hull
closest_points
farthest_points
are_coplanar
are_similar
"""
from __future__ import division, print_function
from sympy import Function, Symbol, solve, sqrt
from sympy.core.compatibility import (
is_sequence, ordered)
from s... |
f5ab37347b84e89758b50c4b829c98107ab0bf9ff3a60fdf83add035604d349e | from __future__ import division, print_function
from sympy.core import Expr, S, Symbol, oo, pi, sympify
from sympy.core.compatibility import as_int, ordered
from sympy.core.symbol import _symbol, Dummy, symbols
from sympy.functions.elementary.complexes import sign
from sympy.functions.elementary.piecewise import Piece... |
7357bfbae66fcbd851dc27e7a948bb71708d5591efd9c6f1e9ce64589eb7c0a3 | """Recurrence Operators"""
from __future__ import print_function, division
from sympy import symbols, Symbol, S
from sympy.printing import sstr
from sympy.core.sympify import sympify
def RecurrenceOperators(base, generator):
"""
Returns an Algebra of Recurrence Operators and the operator for
shifting i.... |
95f88a411b993ec7e43fc6a41abd3f92e879d8ec01ce2c835d6742d44c7d87e9 | """ Linear Solver for Holonomic Functions"""
from __future__ import print_function, division
from sympy.core import S
from sympy.matrices.common import ShapeError
from sympy.matrices.dense import MutableDenseMatrix
class NewMatrix(MutableDenseMatrix):
"""
Supports elements which can't be Sympified.
See ... |
9826ad152a081a3603339cced06c7f15eddbbf3e376f71a743d84c6ffe000ca3 | """
This module implements Holonomic Functions and
various operations on them.
"""
from __future__ import print_function, division
from sympy import (Symbol, S, Dummy, Order, rf, I,
solve, limit, Float, nsimplify, gamma)
from sympy.core.compatibility import ordered
from sympy.core.numbers import NaN, Infinity, Ne... |
44f87735c0247ff6ace572a3eac63e01fb2494c04c943fbae6e64e87aa55897b | from sympy.printing import pycode, ccode, fcode
from sympy.external import import_module
from sympy.utilities.decorator import doctest_depends_on
lfortran = import_module('lfortran')
cin = import_module('clang.cindex', import_kwargs = {'fromlist': ['cindex']})
if not lfortran and not cin:
class SymPyExpression(ob... |
6a31e72ad809a3d7abf892efb198b6346271fa4d17dab8196dfa090ee6093bad | from __future__ import print_function, division
from typing import Any, Dict, Tuple
from itertools import product
import re
from sympy import sympify
def mathematica(s, additional_translations=None):
'''Users can add their own translation dictionary
# Example
In [1]: mathematica('Log3[9]', {'Log3[x]':'l... |
d8a627b85bcb20ee26c198e770004e285d17cd500ecb6adb532ffc6252cb1b28 | # -*- coding: utf-8 -*-
r"""
Wigner, Clebsch-Gordan, Racah, and Gaunt coefficients
Collection of functions for calculating Wigner 3j, 6j, 9j,
Clebsch-Gordan, Racah as well as Gaunt coefficients exactly, all
evaluating to a rational number times the square root of a rational
number [Rasch03]_.
Please see the descripti... |
ee35fe60f1c97a4238a4718b44de1a361d2a5fdaf8e60c9affb596ae04458e4a | """
This module implements Pauli algebra by subclassing Symbol. Only algebraic
properties of Pauli matrices are used (we don't use the Matrix class).
See the documentation to the class Pauli for examples.
References
~~~~~~~~~~
.. [1] https://en.wikipedia.org/wiki/Pauli_matrices
"""
from __future__ import print_funct... |
4ee1af6d82eb7ea666d1730535e1ca824252ed785736ac3da58522beeb0e15bb | from __future__ import print_function, division
from sympy.core import S, pi, Rational
from sympy.functions import assoc_laguerre, sqrt, exp, factorial, factorial2
def R_nl(n, l, nu, r):
"""
Returns the radial wavefunction R_{nl} for a 3d isotropic harmonic
oscillator.
``n``
the "nodal" quan... |
5b1d1f85c5f359d866aae0008b6fbdf71f449c549754196cab071d844e44c2fb | """Known matrices related to physics"""
from __future__ import print_function, division
from sympy import Matrix, I, pi, sqrt
from sympy.functions import exp
def msigma(i):
r"""Returns a Pauli matrix `\sigma_i` with `i=1,2,3`
References
==========
.. [1] https://en.wikipedia.org/wiki/Pauli_matrice... |
69748e006f794510de45f08dc925843a019f5d1d3bf34e4b82874b95ce9b374f | """
Second quantization operators and states for bosons.
This follow the formulation of Fetter and Welecka, "Quantum Theory
of Many-Particle Systems."
"""
from __future__ import print_function, division
from collections import defaultdict
from sympy import (Add, Basic, cacheit, Dummy, Expr, Function, I,
... |
de92d06aa653805bfc1eac5312245231785df4166d0b2c22ab377bdd2beef5be | from sympy import Symbol, Number, sympify
from sympy import MutableDenseNDimArray, S
from sympy.tensor.tensor import (Tensor, TensExpr, TensAdd, TensMul,
TensorIndex)
class PartialDerivative(TensExpr):
"""
Partial derivative for tensor expressions.
Examples
========
... |
ac2dbaf0eccb9c4a774fb3860adffb751165d794d1a6a2bad20af4bbdf08802f | """
This module defines tensors with abstract index notation.
The abstract index notation has been first formalized by Penrose.
Tensor indices are formal objects, with a tensor type; there is no
notion of index range, it is only possible to assign the dimension,
used to trace the Kronecker delta; the dimension can be... |
66030a3aa25aa5f109cc5427192a7c3dcbb6366917a889807cd9f567cb27b201 | r"""Module that defines indexed objects
The classes ``IndexedBase``, ``Indexed``, and ``Idx`` represent a
matrix element ``M[i, j]`` as in the following diagram::
1) The Indexed class represents the entire indexed object.
|
___|___
' '
M[i, j]... |
21d1d7ce5e482275e58266c2ebf39ff24506861f1280b4d311c32d214370281f | from typing import Dict, Any
import inspect
from .dispatcher import Dispatcher, MethodDispatcher, ambiguity_warn
# XXX: This parameter to dispatch isn't documented and isn't used anywhere in
# sympy. Maybe it should just be removed.
global_namespace = dict() # type: Dict[str, Any]
def dispatch(*types, **kwargs):
... |
1fc91a8dbab1411b118821cdd24499e3116f9df58cb5b48f1643885d1a844f3a | from typing import Set
from warnings import warn
import inspect
from .conflict import ordering, ambiguities, super_signature, AmbiguityWarning
from .utils import expand_tuples
import itertools as itl
class MDNotImplementedError(NotImplementedError):
""" A NotImplementedError for multiple dispatch """
def ambig... |
7b394e488a991163950fd649dfab64aaadb412f4c2a9a57fe3f5a716bf31e9f0 | from sympy.utilities.exceptions import SymPyDeprecationWarning
from sympy.core.core import BasicMeta, Registry, all_classes
class ClassRegistry(Registry):
"""
Namespace for SymPy classes
This is needed to avoid problems with cyclic imports.
To get a SymPy class, use `C.<class_name>` e.g. `C.Rational`... |
01dc8421d08f17650833e22c75b782088754ee15a18b42661112b355cf17d1c7 | """
Boolean algebra module for SymPy
"""
from __future__ import print_function, division
from collections import defaultdict
from itertools import chain, combinations, product
from sympy.core.add import Add
from sympy.core.basic import Basic
from sympy.core.cache import cacheit
from sympy.core.compatibility import ord... |
0d1007fb70e9983ce6f4e7be737aca9a1ee8ecaece5b6a9635c387bc3336f3b8 | from __future__ import division, print_function
import os
from sympy.core.function import expand_mul
from sympy.simplify.simplify import dotprodsimp as _dotprodsimp
# The following is an internal variable for controlling the recently introduced
# dotprodsimp intermediate simplification step in matrix operations in ... |
c7d7022008af2111e966926c1eaf266a49a7b7c886bd063ab638b7486715c1c4 | from __future__ import division, print_function
import copy
from sympy.core.function import expand_mul
from sympy.functions.elementary.miscellaneous import Min, sqrt
from .common import NonSquareMatrixError, NonPositiveDefiniteMatrixError
from .utilities import _get_intermediate_simp, _iszero
from .determinant impor... |
272d661a3297c473b4015dcebc4b7fee67bb19bd7129ede1920e05e4ecf4bef2 | from __future__ import division, print_function
from types import FunctionType
from sympy.core.numbers import Float, Integer
from sympy.core.singleton import S
from sympy.core.symbol import _uniquely_named_symbol
from sympy.polys import PurePoly, cancel
from sympy.simplify.simplify import (simplify as _simplify,
... |
80351089d8392f32e7e2f3f69bd50553eeb9a9d23f7bbba30718cc56b2dea547 | from __future__ import division, print_function
from sympy.core.numbers import mod_inverse
from .common import MatrixError, NonSquareMatrixError, NonInvertibleMatrixError
from .utilities import _iszero
def _pinv_full_rank(M):
"""Subroutine for full row or column rank matrices.
For full row rank matrices, i... |
8f646d94e99c1d2f6e77849e4ac9924d354b73d5e99e7814f3b44cab6e766c27 | """
Solution of equations using dense matrices.
The dense matrix is stored as a list of lists.
"""
import copy
from sympy.core.power import isqrt
from sympy.core.symbol import symbols
from sympy.matrices.densetools import (
augment, col, conjugate_transpose, eye, rowadd, rowmul)
from sympy.utilities.exceptions ... |
fbead3c2e19dc6187676135f00970d1cc4664e880ce9eac315a51b3e069e9feb | from __future__ import division, print_function
from types import FunctionType
from sympy.simplify.simplify import (
simplify as _simplify, dotprodsimp as _dotprodsimp)
from .utilities import _get_intermediate_simp, _iszero
from .determinant import _find_reasonable_pivot
def _row_reduce_list(mat, rows, cols, o... |
105bd4d43bd98a6cb6e994e4ec2354c351b6cbfe82b5a0c3e996038d5192d9c2 | """
Fundamental operations of dense matrices.
The dense matrix is stored as a list of lists
"""
from sympy.utilities.exceptions import SymPyDeprecationWarning
SymPyDeprecationWarning(
feature="densetools",
issue=12695,
deprecated_since_version="1.1").warn()
def trace(matlist, K):
"""
Returns the... |
89ebaebde2c98303b53f62f1244a32337f8ff970f0ed3e6d4bd4897b9ce97b8c | """
Fundamental arithmetic of dense matrices. The dense matrix is stored
as a list of lists.
"""
from sympy.utilities.exceptions import SymPyDeprecationWarning
SymPyDeprecationWarning(
feature="densearith",
issue=12695,
deprecated_since_version="1.1").warn()
def add(matlist1, matlist2, K):
"""
A... |
5839d957cd9a4be7e0f969f576c89a39fddf7ba3e4a5ed7de0cec978e3140100 | from __future__ import division, print_function
from typing import Callable
from sympy.core import Basic, Dict, Integer, S, Tuple
from sympy.core.cache import cacheit
from sympy.core.sympify import converter as sympify_converter
from sympy.matrices.dense import DenseMatrix
from sympy.matrices.expressions import Matri... |
1825f2c6ed5beac71b26e4b6559be73315b0c6f4682b13979956add2873f717e | """
Basic methods common to all matrices to be used
when creating more advanced matrices (e.g., matrices over rings,
etc.).
"""
from __future__ import division, print_function
from sympy.core.logic import FuzzyBool
from collections import defaultdict
from inspect import isfunction
from sympy.assumptions.refine impo... |
513d1f5007887289acb91ae2971bd6e4b3cbb55e30e729ae583342ab2f3ed630 | from __future__ import division, print_function
import random
from sympy.core import SympifyError, Add
from sympy.core.basic import Basic
from sympy.core.compatibility import is_sequence, reduce
from sympy.core.expr import Expr
from sympy.core.singleton import S
from sympy.core.symbol import Symbol
from sympy.core.sy... |
fbba7eea468d787601e2343ffeedcdf4ea7b45911de29c4d0fb9775a72f4f155 | from __future__ import division, print_function
from sympy.core.function import expand_mul
from sympy.core.symbol import Dummy, _uniquely_named_symbol, symbols
from sympy.utilities.iterables import numbered_symbols
from .common import ShapeError, NonSquareMatrixError, NonInvertibleMatrixError
from .utilities import _... |
a6d2e3d090a106194b7a136c4d5f802a9f814c0335a0d1966af6adc011218972 | from __future__ import division, print_function
from collections import defaultdict
from sympy.core import SympifyError, Add
from sympy.core.compatibility import Callable, as_int, is_sequence, reduce
from sympy.core.containers import Dict
from sympy.core.expr import Expr
from sympy.core.singleton import S
from sympy.... |
ed3c77a15d39b5ee5cb5e7973eeb7391413863dd0e6cb59b5969deaaf0bcc123 | from __future__ import division, print_function
from typing import Any
from sympy.core.add import Add
from sympy.core.basic import Basic
from sympy.core.compatibility import (
Callable, NotIterable, as_int, is_sequence)
from sympy.core.decorators import deprecated
from sympy.core.expr import Expr
from sympy.core.... |
27ba29b83a1e818415d6cc42a94b684825f2fe4070ac9e7c360dfa123a5c9a76 | from __future__ import division, print_function
from types import FunctionType
from mpmath.libmp.libmpf import prec_to_dps
from sympy.core.compatibility import default_sort_key
from sympy.core.logic import fuzzy_and, fuzzy_or
from sympy.core.numbers import Float
from sympy.core.symbol import Dummy
from sympy.functio... |
d0698c431fd28e5de47948293ab2fff511976c7dc3e958084ebca61aec483e61 | from __future__ import division, print_function
from sympy.core.compatibility import reduce
from .utilities import _iszero
def _columnspace(M, simplify=False):
"""Returns a list of vectors (Matrix objects) that span columnspace of ``M``
Examples
========
>>> from sympy.matrices import Matrix
>... |
1e054d0d7f2dc8789bb7661e56270a1e188eb0ebb1aceb06448b420edb201b26 | from __future__ import division, print_function
from sympy.core.compatibility import as_int
from sympy.utilities.iterables import is_sequence
from sympy.utilities.misc import filldedent
from .sparse import SparseMatrix
def _doktocsr(dok):
"""Converts a sparse matrix to Compressed Sparse Row (CSR) format.
P... |
a99145af45117de60ee6fe5eaba710423258dc07e666452139bb9febdc7f29c2 | from sympy.core import Basic, Integer
import operator
class OmegaPower(Basic):
"""
Represents ordinal exponential and multiplication terms one of the
building blocks of the Ordinal class.
In OmegaPower(a, b) a represents exponent and b represents multiplicity.
"""
def __new__(cls, a, b):
... |
a037e004460158010928c037e7724cb92e158efb9467719e7f7a8f2822419bd1 | from __future__ import print_function, division
from functools import reduce
from sympy.core.basic import Basic
from sympy.core.containers import Tuple
from sympy.core.expr import Expr
from sympy.core.function import Lambda
from sympy.core.logic import fuzzy_not, fuzzy_or, fuzzy_and
from sympy.core.numbers import oo,... |
768c5e27f79e2a674ef7831aef839bb280a75883757a192bcca87989d8ee1296 | from __future__ import print_function, division
from typing import Optional
from collections import defaultdict
import inspect
from sympy.core.basic import Basic
from sympy.core.compatibility import iterable, ordered, reduce
from sympy.core.containers import Tuple
from sympy.core.decorators import (deprecated, sympi... |
19522341ae28760b75bce272897d9e5eac10a5917b907fdbeab2d721b66ce093 | """Plotting module for Sympy.
A plot is represented by the ``Plot`` class that contains a reference to the
backend and a list of the data series to be plotted. The data series are
instances of classes meant to simplify getting points and meshes from sympy
expressions. ``plot_backends`` is a dictionary with all the bac... |
82bd1368f69672a4779f1ddd7a665f8991554bc85a0815d03eedeb44c249bcfe | from __future__ import print_function, division
from sympy.core.numbers import Float
from sympy.core.symbol import Dummy
from sympy.utilities.lambdify import lambdify
import math
def is_valid(x):
"""Check if a floating point number is valid"""
if x is None:
return False
if isinstance(x, complex)... |
3cc267ec41f230dfe79c865647f57c0056dae13ad826d0eea1e85dbfcac789ce | """ rewrite of lambdify - This stuff is not stable at all.
It is for internal use in the new plotting module.
It may (will! see the Q'n'A in the source) be rewritten.
It's completely self contained. Especially it does not use lambdarepr.
It does not aim to replace the current lambdify. Most importantly it will never... |
6af8688add823501486dd497c4d47a1d36cb15a7a1bb030e93fbafb480bd1b38 | from __future__ import unicode_literals
from sympy import (S, Symbol, Interval, exp,
symbols, Eq, cos, And, Tuple, integrate, oo, sin, Sum, Basic,
DiracDelta, Lambda, log, pi, FallingFactorial, Rational)
from sympy.stats import (Die, Normal, Exponential, FiniteRV, P, E, H, variance,
density, giv... |
745b1bca727fb88c8ecab296f7f0691a3eff48ae5e888a55b7f78a7ab3ddf1f2 | from sympy import (FiniteSet, S, Symbol, sqrt, nan, beta, Rational, symbols,
simplify, Eq, cos, And, Tuple, Or, Dict, sympify, binomial,
cancel, exp, I, Piecewise, Sum, Dummy)
from sympy.external import import_module
from sympy.matrices import Matrix
from sympy.stats import (Discre... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.