hash stringlengths 64 64 | content stringlengths 0 1.51M |
|---|---|
120a6ae012200eeabbbca4ee2aa8089f138e3b40344f883d78477762ef6ed645 | """Base class for all the objects in SymPy"""
from collections import defaultdict
from itertools import chain, zip_longest
from .assumptions import BasicMeta, ManagedProperties
from .cache import cacheit
from .sympify import _sympify, sympify, SympifyError
from .compatibility import iterable, ordered, Mapping
from .si... |
413e12183975b51f0994b477448fbb03125695fd401b78be516bd170dec96f23 | from math import log as _log
from .sympify import _sympify
from .cache import cacheit
from .singleton import S
from .expr import Expr
from .evalf import PrecisionExhausted
from .function import (_coeff_isneg, expand_complex, expand_multinomial,
expand_mul)
from .logic import fuzzy_bool, fuzzy_not, fuzzy_and
from .... |
f41778e30fc1e8205db432ca309775ada3e23014d6cbb54ba780fc358c4049c6 | """Tools for manipulating of large commutative expressions. """
from sympy.core.add import Add
from sympy.core.compatibility import iterable, is_sequence, SYMPY_INTS
from sympy.core.mul import Mul, _keep_coeff
from sympy.core.power import Pow
from sympy.core.basic import Basic, preorder_traversal
from sympy.core.expr ... |
2d823e01c5e9b0bc2b7788412e5319a77aa44d89b716189932833d48524f6c8c | """Singleton mechanism"""
from typing import Any, Dict, Type
from .core import Registry
from .assumptions import ManagedProperties
from .sympify import sympify
class SingletonRegistry(Registry):
"""
The registry for the singleton classes (accessible as ``S``).
This class serves as two separate things.... |
33012501090e27ecda8c939a03540d06f13124fa6e628c3fa7b9a28917053f9f | """
There are three types of functions implemented in SymPy:
1) defined functions (in the sense that they can be evaluated) like
exp or sin; they have a name and a body:
f = exp
2) undefined function which have a name but no body. Undefined
functions can be defined using a Function cla... |
96a9ef85d547acac624be798cd43b8ec2695e0e69c9cf28f5b36391be8d901a2 | from collections import defaultdict
from functools import cmp_to_key
from .basic import Basic
from .compatibility import reduce, is_sequence
from .parameters import global_parameters
from .logic import _fuzzy_group, fuzzy_or, fuzzy_not
from .singleton import S
from .operations import AssocOp
from .cache import cacheit
... |
34c1b0035ea9b9e8299783bbdb0598a74aa158e8b2e70f41b5e097a219afe9f0 | from typing import Tuple as tTuple
from .sympify import sympify, _sympify, SympifyError
from .basic import Basic, Atom
from .singleton import S
from .evalf import EvalfMixin, pure_complex
from .decorators import call_highest_priority, sympify_method_args, sympify_return
from .cache import cacheit
from .compatibility i... |
0e7ec31942b69593e56301ebd13e25440d0c244b1336849c4e4e826ac1d5e9f1 | from typing import Dict, Type, Union
from sympy.utilities.exceptions import SymPyDeprecationWarning
from .add import _unevaluated_Add, Add
from .basic import S, Atom
from .compatibility import ordered
from .basic import Basic
from .expr import Expr
from .evalf import EvalfMixin
from .sympify import _sympify
from .para... |
97c931b8f89a3d3a556440f9ec0be3e7022dd8a0a1d580f8e7d306d298f9b399 | import numbers
import decimal
import fractions
import math
import re as regex
from .containers import Tuple
from .sympify import (SympifyError, converter, sympify, _convert_numpy_types, _sympify,
_is_numpy_instance)
from .singleton import S, Singleton
from .expr import Expr, AtomicExpr
from .eval... |
f4b44a49bf33d862d3f3c3766e4b6469dd85d98d5a36ba88f86838b1db49e173 | from typing import Tuple
from sympy.utilities.exceptions import SymPyDeprecationWarning
from sympy.core.sympify import _sympify, sympify
from sympy.core.basic import Basic
from sympy.core.cache import cacheit
from sympy.core.compatibility import ordered
from sympy.core.logic import fuzzy_and
from sympy.core.parameter... |
b7336ee2828807388475ecec8e4e2f471f3347ce5102d06f6a0f7de7ca7bf47b | from sympy.core.assumptions import StdFactKB, _assume_defined
from sympy.core.compatibility import is_sequence, ordered
from .basic import Basic
from .sympify import sympify
from .singleton import S
from .expr import Expr, AtomicExpr
from .cache import cacheit
from .function import FunctionClass
from sympy.core.logic i... |
cf71309d4e5bea5c21891555d042d998c66d3aee5fc67560864fea559b4c231c | """
Reimplementations of constructs introduced in later versions of Python than
we support. Also some functions that are needed SymPy-wide and are located
here for easy import.
"""
from typing import Tuple, Type
import operator
from collections import defaultdict
from sympy.external import import_module
"""
Python 2... |
fddbf3e05cb7befcddf957ea82595df6e1a4b8e74036fd4962187a7b59cb25db | """sympify -- convert objects SymPy internal format"""
from typing import Dict, Type, Callable, Any
from inspect import getmro
from .compatibility import iterable
from .parameters import global_parameters
class SympifyError(ValueError):
def __init__(self, expr, base_exc=None):
self.expr = expr
... |
65e5c077aa334548aab18a00f9ebbbb8305c5a1f0c0f758c29c15e8d10540de6 | """ Caching facility for SymPy """
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__
myfunc = item
while hasattr(myfunc... |
c8f30022a3accc578fb357a1c3d7c8a84dc26753121209aefd27721b0eb236a3 | 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, fuzzy_and
from .compatibility import reduce
from .ex... |
3a8b4f7f65ee1901104bcf0ac403f72c2db6228a7474e2afe58e3893259b8df3 | """Tools for setting up printing in interactive sessions. """
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_printing(stringify_func, **settings):
"""Setu... |
7111994b915b719ecdd1fe6ebd52eaee8ecddb24908f09e3449f61ee279c1141 | """Tools for setting up interactive sessions. """
from distutils.version import LooseVersion as V
from sympy.interactive.printing import init_printing
preexec_source = """\
from __future__ import division
from sympy import *
x, y, z, t = symbols('x y z t')
k, m, n = symbols('k m n', integer=True)
f, g, h = symbols('... |
81159a317c643b4b1d400e6f0a239fe4d7d6862cb0abf36e2c496b02e516755f | """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... |
c2d16b682a0d52cd159ddac2cb37fbfa283dbad99fee391c9c3f3fc85254b9c3 | """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... |
808f388e850c4a779f6bbce056df54840e1387421ac6edd533154aaf99a4f2df | """Square-free decomposition algorithms and related tools. """
from __future__ import print_function, division
from sympy.polys.densearith import (
dup_neg, dmp_neg,
dup_sub, dmp_sub,
dup_mul,
dup_quo, dmp_quo,
dup_mul_ground, dmp_mul_ground)
from sympy.polys.densebasic import (
dup_strip,
... |
d02dce7e55806d165e0f977204e774c0e448f4f73187ad49da2995bee573f6ac | """User-friendly public interface to polynomial functions. """
from __future__ import print_function, division
from functools import wraps, reduce
from operator import mul
from sympy.core import (
S, Basic, Expr, I, Integer, Add, Mul, Dummy, Tuple
)
from sympy.core.basic import preorder_traversal
from sympy.core... |
15bcde60895bbc47721d8780a3a8947e9f9e17558690c80ba5a201fb3f449bb4 | """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 ... |
3fcbdfc8130651de06cdd6e427bab778ddb5369c40cb2f18ea9eb4d7f01565ac | """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... |
8e643a2061e5bc4c1c49a42d563194c8912a0fccbba07f0db70367580dc19011 | """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... |
50f4d9aaf7322d13a350a033cc4ba1075ed29257aa4fba1422014205a06a85aa | """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... |
ffcebbbfaca935c0d6286bd9775e7f2ba976d0eb0321c9914bba0ba32346629f | """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 ... |
46f31d015dead184a823018e322d67d3e9548fcf2f58bfd8a82df998d4fd4ab7 | """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)
... |
f548a360d81464d44d682356933cc9a99c987cd4baa3cc9b3e6e2522de8731c6 | """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... |
493ba6e72f76bf4dccdd59c9b24fe5f08c0a5d1472432e85050dfc7c20625c9f | 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... |
10ba4867db043829ec0285fd1477ab3b4469e7ada5345e8c542d58b0a3b06b81 | """ SymPy interface to Unification engine
See sympy.unify for module level docstring
See sympy.unify.core for algorithmic docstring """
from __future__ import print_function, division
from sympy.core import Basic, Add, Mul, Pow
from sympy.core.operations import AssocOp, LatticeOp
from sympy.matrices import MatAdd, M... |
18251f46aec8cda3094376ae0cc3d5ff945b44704a17836e7eafab9a77d63244 | """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... |
8831d14d364921b1c926c7e58eb05f719f0baad3e8ccb8ed58be4ce7b9ef469d | 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... |
2e55a088440d88eb5720274280a657a0db36cc14307fabb2ffc1d40d2e497f87 | 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... |
b050fc8d332c1c454106a1ca44ca7ea28e5902d97720fb7a1c62555c2f237b20 | from sympy.vector.coordsysrect import CoordSys3D
from sympy.vector.deloperator import Del
from sympy.vector.scalar import BaseScalar
from sympy.vector.vector import Vector, BaseVector
from sympy.vector.operators import gradient, curl, divergence
from sympy import diff, integrate, S, simplify
from sympy.core import symp... |
a07d5c0bfad600839dcc887a6d60f537a8e54a8574fb66560c31be6d0ee53bc6 | """Curves in 2-dimensional Euclidean space.
Contains
========
Curve
"""
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 sympy.geometry.entity import GeometryEntity, Geometry... |
7dc1a6d39df3bec5f23d99767a7799acb99b9ee55c9ae79cf3c0f8a33e480e0a | """Geometrical Points.
Contains
========
Point
Point2D
Point3D
When methods of Point require 1 or more points as arguments, they
can be passed as a sequence of coordinates or Points:
>>> from sympy.geometry.point import Point
>>> Point(1, 1).is_collinear((2, 2), (3, 4))
False
>>> Point(1, 1).is_collinear(Point(2, 2)... |
35fc914ea49fad28e761493b28da70b9b70aeda86511264411c45893183912fa | """Geometrical Planes.
Contains
========
Plane
"""
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.trigonometric import cos, sin, acos, asin, sqrt
from sy... |
dc09e7fbfd9ed43490cd457693f5a58a3488f2ad2a3203ee4f8ea7fb0a8fb3d6 | """Elliptical geometrical entities.
Contains
* Ellipse
* Circle
"""
from sympy import Expr, Eq
from sympy.core import S, pi, sympify
from sympy.core.parameters import global_parameters
from sympy.core.logic import fuzzy_bool
from sympy.core.numbers import Rational, oo
from sympy.core.compatibility import ordered
fro... |
93584ac3f0a1bf38ed76e36c61a0393473b863bd56d58f7c8a125d51be139533 | """Utility functions for geometrical entities.
Contains
========
intersection
convex_hull
closest_points
farthest_points
are_coplanar
are_similar
"""
from sympy import Function, Symbol, solve, sqrt
from sympy.core.compatibility import (
is_sequence, ordered)
from sympy.core.containers import OrderedSet
from .poi... |
8d76770b8ff92e17ade859ef036fa443913023ab02c4814dd799876218e30715 | """Line-like geometrical entities.
Contains
========
LinearEntity
Line
Ray
Segment
LinearEntity2D
Line2D
Ray2D
Segment2D
LinearEntity3D
Line3D
Ray3D
Segment3D
"""
from sympy import Expr
from sympy.core import S, sympify
from sympy.core.compatibility import ordered
from sympy.core.containers import Tuple
from sympy.c... |
00b65f6c39f515324779dd0761659d71478d1edb3362fedb64aa07e70e61d493 | 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 Piecewise
from sympy.functions.elementary.trigonometri... |
1a3e6fc6f0df92bdf0b983c36a6ba7a8a95352f7d2770606e8fccc339dba66f1 | """Recurrence Operators"""
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.e. the `Sn` operator.
The first argument need... |
2c393651db5efc09a15397ff0c604a2aa40277d99156a69e040e21ac48e91b60 | """
This module implements Holonomic Functions and
various operations on them.
"""
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, NegativeInfinity
from sympy.core.sympify import sym... |
e7908c2f23060bbcacf7c3bc25ed0b9db46bf89f74a75ce47e7580ecf43cd280 | # -*- 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... |
6ab5caaf21ddfdf6d6bd2aacd887bb20ab3e54f2b0c0224d29ba8743bb7092e5 | """
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... |
809005f29410e40444aeadd7000e8430dc18e3be1f8a45fc6f041b68b5e479b5 | 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... |
1d22ef1c66e00b854ac36c6e11779b42016257a84c9030cced0a0c8fba2dbb57 | from __future__ import print_function, division
from sympy.core import S, pi, Rational
from sympy.functions import hermite, sqrt, exp, factorial, Abs
from sympy.physics.quantum.constants import hbar
def psi_n(n, x, m, omega):
"""
Returns the wavefunction psi_{n} for the One-dimensional harmonic oscillator.
... |
3071cabbff7837c57d5d95324d09d1b079260d25effc6ab44a3febd694d8f700 | from __future__ import print_function, division
from sympy import factorial, sqrt, exp, S, assoc_laguerre, Float
from sympy.functions.special.spherical_harmonics import Ynm
def R_nl(n, l, r, Z=1):
"""
Returns the Hydrogen radial wavefunction R_{nl}.
n, l
quantum numbers 'n' and 'l'
r
... |
0684613112462a902ff36014c45ccd8ece6c487b74e907682524e77e831ebdc6 | """
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,
... |
26395d1af79d75b0888826ed402416f0d1fcb9e7c3837bf38fa89b9e14178305 | from __future__ import print_function, division
from sympy import sqrt, exp, S, pi, I
from sympy.physics.quantum.constants import hbar
def wavefunction(n, x):
"""
Returns the wavefunction for particle on ring.
n is the quantum number, x is the angle,
here n can be positive as well as negative
whi... |
d5973a6ae70fc8c6001a2c1cc3ff1151aaa7d0b6dfdefb83c3b8d4c0e7cb00ea | """Module with functions operating on IndexedBase, Indexed and Idx objects
- Check shape conformance
- Determine indices in resulting expression
etc.
Methods in this module could be implemented by calling methods on Expr
objects instead. When things stabilize this could be a useful
refactori... |
c8755a23292855f1aacf0b681a85ee94b43f6d9ad1a7a64cc933cbfb434ff8cc | 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]... |
026ed521cedcfe06c6496f3635b246315c8847589d702ee70e6e97254b02c8f1 | 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):
... |
6a3834d54f2777f68a1e3f8bd90d4b613ecda40a819e3600407ff8ad703c7da3 | 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... |
8e33bb989e2bcdfb6fbe86291f90e6e9c610269b5f82831d16a76664d7fd4318 | """
Boolean algebra module for SymPy
"""
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 ordered, as_int
from sympy.core.function import App... |
a0f7d986fc0f25aa6659223beca1f8baa794ff0e56b7822de497c6f63d6f360d | """Inference in propositional logic"""
from sympy.logic.boolalg import And, Not, conjuncts, to_cnf
from sympy.core.compatibility import ordered
from sympy.core.sympify import sympify
from sympy.external.importtools import import_module
def literal_symbol(literal):
"""
The symbol in this literal (without the ... |
70cc62cea630574ee7e8a4de0df80ee6e2e61b28bda8c7b425f25e117fed0784 | 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 import _find_reasonable_pivot_naive
def _rank_decomp... |
1e9afc64769769b6352724bc9d77d5c8f1a640434840f9ee6c34d4ad0054e7c8 | 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,
dotprodsimp as _dotprodsimp)
from .common import ... |
d69f40ee54a3ed9dd80e929b05b77ae74025a61a3fe1f8f9631cd13849c380ac | """
Basic methods common to all matrices to be used
when creating more advanced matrices (e.g., matrices over rings,
etc.).
"""
from sympy.core.logic import FuzzyBool
from collections import defaultdict
from inspect import isfunction
from sympy.assumptions.refine import refine
from sympy.core import SympifyError, Ad... |
d76095d6c84214b2b1815f6615f5a55ecb1fa9cf561e005920a0e19cbb416c99 | 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.sympify import sympify
from sympy.functions.element... |
465737bf59dc02d676a91c2442e0e51207186d171db2c6244e4f3afaf13f50e5 | 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 .eigen import _fuzzy_positive_definite
from .utilities import _get_in... |
b25952dd3a1000f33032fee29901dbce75ef27aa119e29b3f0b3b97b4b87fb89 | from typing import Any
import mpmath as mp
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.power import Pow
from sympy.c... |
6d28800badbbbc81e9a49ba9b1f05caa0c48ed33a1cd2106ca2f2f908f401ad7 | from types import FunctionType
from collections import Counter
from mpmath import mp, workprec
from mpmath.libmp.libmpf import prec_to_dps
from sympy.core.compatibility import default_sort_key
from sympy.core.evalf import DEFAULT_MAXPREC, PrecisionExhausted
from sympy.core.logic import fuzzy_and, fuzzy_or
from sympy.... |
9bf599d4646c3d3f269edbcee8872e69447b6ab48fe35a92585d91e14ff43471 | 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):
... |
b860d8d9042af9ba2511632bcb28ff5069ee32d92b67e64f969a8b10da4b18ee | 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,... |
5940caa3d4a0fbb404a34d6e162abc76836e80c8c1a437dfd48a6d5958e6dd14 | 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... |
882551e475755dc2eadaa663d58ec333707c0502643ad56efb244db5b8929e64 | """Implicit plotting module for SymPy
The module implements a data series called ImplicitSeries which is used by
``Plot`` class to plot implicit plots for different backends. The module,
by default, implements plotting using interval arithmetic. It switches to a
fall back algorithm if the expression cannot be plotted ... |
10a2e3680c19b3c1fdce205a063246b40f9fdb833e9f2659721e21298dc560a2 | """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... |
63e166c33bcd5582bf9aa383a094a8592a359fc0a50384950e93c5f2c5980d0a | """ 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... |
a76157c28a1cb5aa0bccadf81dabef72050fe3b1d3222655a2fc706aad450cb8 | from __future__ import unicode_literals
from sympy import (S, Symbol, Interval, exp, Or,
symbols, Eq, cos, And, Tuple, integrate, oo, sin, Sum, Basic, Indexed,
DiracDelta, Lambda, log, pi, FallingFactorial, Rational, Matrix)
from sympy.stats import (Die, Normal, Exponential, FiniteRV, P, E, H, variance,... |
9d7aed36ec0b609a8f080239224a9eb28a8dc8a7b563e4ef296eac4f8e9d1875 | 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... |
39d0ad4cf90ebc904f43c9837d946f23ad82d72d7089026945c3daad01af9e05 | from sympy import symbols, Mul, sin, Integral, oo, Eq, Sum
from sympy.core.expr import unchanged
from sympy.stats import (Normal, Poisson, variance, Covariance, Variance,
Probability, Expectation)
from sympy.stats.rv import probability, expectation
def test_literal_probability():
X = Norm... |
f5ebcad0ebacdeb3f578e36d9f7df0759ece9745a010e95bb53d0eb1fece08b5 | from sympy import (S, symbols, FiniteSet, Eq, Matrix, MatrixSymbol, Float, And,
ImmutableMatrix, Ne, Lt, Gt, exp, Not, Rational, Lambda, Sum,
Piecewise)
from sympy.stats import (DiscreteMarkovChain, P, TransitionMatrixOf, E,
StochasticStateSpaceOf, variance... |
75a582059ee8fe03823dee50b87087bb6cc47a0874264f4c05af4baa7b122341 | from sympy import (S, Symbol, Sum, I, lambdify, re, im, log, simplify, sqrt,
zeta, pi, besseli, Dummy, oo, Piecewise, Rational, beta,
floor, FiniteSet)
from sympy.core.relational import Eq, Ne
from sympy.functions.elementary.exponential import exp
from sympy.logic.boolalg import Or... |
3469c685e38bd564efca5bac4166c7c8f075d40206f2e506ba94e6e2b48c2002 | from sympy import E as e
from sympy import (Symbol, Abs, exp, expint, S, pi, simplify, Interval, erf, erfc, Ne,
EulerGamma, Eq, log, lowergamma, uppergamma, symbols, sqrt, And,
gamma, beta, Piecewise, Integral, sin, cos, tan, sinh, cosh,
besseli, floor, expand_fu... |
b94e4ca4e9ff4b3c995d8ac98d92f682ae47a778cdaf6afda169628f6ea4aaed | from sympy import sin, cos, exp, E, series, oo, S, Derivative, O, Integral, \
Function, log, sqrt, Symbol, Subs, pi, symbols, atan, LambertW, Rational
from sympy.abc import x, y, n, k
from sympy.testing.pytest import raises
from sympy.series.gruntz import calculate_series
def test_sin():
e1 = sin(x).series(x,... |
cd3e7c7a9fabb224a1a21a071f379c5f147206f0e786a325068e8359ae86c8ca | from sympy import (symbols, pi, Piecewise, sin, cos, sinc, Rational, S,
oo, fourier_series, Add, log, exp, tan)
from sympy.series.fourier import FourierSeries
from sympy.testing.pytest import raises
from sympy.core.cache import lru_cache
x, y, z = symbols('x y z')
# Don't declare these during impor... |
d4c902ac8fabb00d0a67e17f042b9f2d421aaef705e977a19094a53a982173ec | from itertools import product as cartes
from sympy import (
limit, exp, oo, log, sqrt, Limit, sin, floor, cos, ceiling,
atan, Abs, gamma, Symbol, S, pi, Integral, Rational, I,
tan, cot, integrate, Sum, sign, Function, subfactorial, symbols,
binomial, simplify, frac, Float, sec, zoo, fresnelc, fresnels,... |
84f5ecfe6e8cbacc3e35a5999482ec45cef0a3efb07b242054c1526af4f0711b | from sympy import (Symbol, Rational, ln, exp, log, sqrt, E, O, pi, I, sinh,
sin, cosh, cos, tanh, coth, asinh, acosh, atanh, acoth, tan, cot, Integer,
PoleError, floor, ceiling, asin, symbols, limit, Piecewise, Eq, sign,
Derivative, S)
from sympy.abc import x, y, z
from sympy.testing.pytest import raises, ... |
84b313ec6a27c0039a9f0478995f4948f274ab20e39be81ead544224a2e0351d | from sympy import (
sqrt, Derivative, symbols, collect, Function, factor, Wild, S,
collect_const, log, fraction, I, cos, Add, O,sin, rcollect,
Mul, Pow, radsimp, diff, root, Symbol, Rational, exp, Abs)
from sympy.core.expr import unchanged
from sympy.core.mul import _unevaluated_Mul as umul
from sympy.simp... |
4a582e1b29a2a105cdc433dd6f9a11835b555c8fa4d653fd6a005cbb4d6dcece | from sympy import ratsimpmodprime, ratsimp, Rational, sqrt, pi, log, erf, GF
from sympy.abc import x, y, z, t, a, b, c, d, e
def test_ratsimp():
f, g = 1/x + 1/y, (x + y)/(x*y)
assert f != g and ratsimp(f) == g
f, g = 1/(1 + 1/x), 1 - 1/(x + 1)
assert f != g and ratsimp(f) == g
f, g = x/(x + ... |
6000449bda4177926661caaad00f25e9397fba5e0ce6fbd7cb17abd5e8aff8e4 | from sympy import symbols, IndexedBase, Identity, cos, Inverse
from sympy.codegen.array_utils import (CodegenArrayContraction,
CodegenArrayTensorProduct, CodegenArrayDiagonal,
CodegenArrayPermuteDims, CodegenArrayElementwiseAdd,
... |
553e676b0548b8f12eeab943da643c6fa5ae12b8c50dcba4abe170639df41178 | """
This module contains query handlers responsible for calculus queries:
infinitesimal, finite, etc.
"""
from sympy.logic.boolalg import conjuncts
from sympy.assumptions import Q, ask
from sympy.assumptions.handlers import CommonHandler
class AskFiniteHandler(CommonHandler):
"""
Handler for key 'finite'.
... |
f19b35c993aca83cc94d743197f3ee71ae82007c1113dc9cd0378ea8eb18b321 | """
This module implements some special functions that commonly appear in
combinatorial contexts (e.g. in power series); in particular,
sequences of rational numbers such as Bernoulli and Fibonacci numbers.
Factorials, binomial coefficients and related functions are located in
the separate 'factorials' module.
"""
fr... |
d76d819d1aeecb8c0c753e926ca89b47624b6fe263277ed6021cc13acc7cc8c9 | from typing import List
from sympy.core import S, sympify, Dummy, Mod
from sympy.core.cache import cacheit
from sympy.core.compatibility import reduce, HAS_GMPY
from sympy.core.function import Function, ArgumentIndexError
from sympy.core.logic import fuzzy_and
from sympy.core.numbers import Integer, pi
from sympy.core... |
7898e85b7ba2246b434e7302eb6b9b23e3a1230e059d12db943db8b4b0c374fa | from sympy.core.add import Add
from sympy.core.basic import sympify, cacheit
from sympy.core.function import Function, ArgumentIndexError, expand_mul
from sympy.core.logic import fuzzy_not, fuzzy_or, FuzzyBool
from sympy.core.numbers import igcdex, Rational, pi
from sympy.core.relational import Ne
from sympy.core.singl... |
7cf3a8eb00bd83ea66bb00e7a35cbdc2b352cb0d0dd19c21366ea595addaf7d4 | from sympy.core import Function, S, sympify
from sympy.core.add import Add
from sympy.core.containers import Tuple
from sympy.core.operations import LatticeOp, ShortCircuit
from sympy.core.function import (Application, Lambda,
ArgumentIndexError)
from sympy.core.expr import Expr
from sympy.core.mod import Mod
from ... |
75089ab3c1e8b96b90312bbfe1a979dd2228ef4aadc4faf21d2e7a987664560d | from sympy.core import Basic, S, Function, diff, Tuple, Dummy
from sympy.core.basic import as_Basic
from sympy.core.numbers import Rational, NumberSymbol
from sympy.core.relational import (Equality, Unequality, Relational,
_canonical)
from sympy.functions.elementary.miscellaneous import Max, Min
from sympy.logic.bo... |
c955d1053444c6c9876a227ee94ff644c948c3f2c7d2ae709d1af73fbb19d88b | from sympy.core import Add, S
from sympy.core.evalf import get_integer_part, PrecisionExhausted
from sympy.core.function import Function
from sympy.core.logic import fuzzy_or
from sympy.core.numbers import Integer
from sympy.core.relational import Gt, Lt, Ge, Le, Relational
from sympy.core.symbol import Symbol
from sym... |
d74586235167fcbaad2e731dc21e42c30946e070e4a556a6b3d7fb89eb897593 | from sympy.core import sympify
from sympy.core.add import Add
from sympy.core.cache import cacheit
from sympy.core.function import (Function, ArgumentIndexError, _coeff_isneg,
expand_mul)
from sympy.core.logic import fuzzy_and, fuzzy_not, fuzzy_or
from sympy.core.mul import Mul
from sympy.core.numbers import In... |
f73271cafe0a5fbd526bfbbc125537149749a5f14d0c438e391465d200d8d2b6 | from sympy.core import S, Add, Mul, sympify, Symbol, Dummy, Basic
from sympy.core.expr import Expr
from sympy.core.exprtools import factor_terms
from sympy.core.function import (Function, Derivative, ArgumentIndexError,
AppliedUndef)
from sympy.core.logic import fuzzy_not, fuzzy_or
from sympy.core.numbers import pi... |
01eb1f44839f11ec047b93fb7ec14d844e42c0ca1514dcef862c411735a652d1 | from sympy.core import Add, S, sympify, oo, pi, Dummy, expand_func
from sympy.core.compatibility import as_int
from sympy.core.function import Function, ArgumentIndexError
from sympy.core.logic import fuzzy_and, fuzzy_not
from sympy.core.numbers import Rational
from sympy.core.power import Pow
from sympy.functions.spec... |
fc1d4df566d639518827ede391a7c25aacfe25a7c24a98597151d1842e134dfc | from sympy.core import S, sympify, diff
from sympy.core.decorators import deprecated
from sympy.core.function import Function, ArgumentIndexError
from sympy.core.logic import fuzzy_not
from sympy.core.relational import Eq, Ne
from sympy.functions.elementary.complexes import im, sign
from sympy.functions.elementary.piec... |
1d6c516bdc9bdb340b7a8b47cbcff746eae4c17b1e3568e0a598a48642d0ff7d | from functools import wraps
from sympy import S, pi, I, Rational, Wild, cacheit, sympify
from sympy.core.function import Function, ArgumentIndexError
from sympy.core.power import Pow
from sympy.functions.combinatorial.factorials import factorial
from sympy.functions.elementary.trigonometric import sin, cos, csc, cot
f... |
4dfd1c2be0a376f480aa81fdbcffacf51266d3a016b1c7ead0f113305b0402d8 | from sympy.core import S, Integer
from sympy.core.compatibility import SYMPY_INTS
from sympy.core.function import Function
from sympy.core.logic import fuzzy_not
from sympy.core.mul import prod
from sympy.utilities.iterables import (has_dups, default_sort_key)
##########################################################... |
2840df2f6dfe81eb774468b8543a7e3482860cef930a990156d73bfae616f664 | """ Elliptic Integrals. """
from sympy.core import S, pi, I, Rational
from sympy.core.function import Function, ArgumentIndexError
from sympy.functions.elementary.complexes import sign
from sympy.functions.elementary.hyperbolic import atanh
from sympy.functions.elementary.miscellaneous import sqrt
from sympy.functions... |
1ff9d87a1464b051331aae06226360adfe3e75cc1bdf4b908bb7faf295b9c91c | """ This module contains various functions that are special cases
of incomplete gamma functions. It should probably be renamed. """
from sympy.core import Add, S, sympify, cacheit, pi, I, Rational
from sympy.core.function import Function, ArgumentIndexError
from sympy.core.symbol import Symbol
from sympy.functions... |
f9ff6144a0e926dccb352d25bf22971e513c00bf0098e1bd1e02158a367f5347 | """
This module mainly implements special orthogonal polynomials.
See also functions.combinatorial.numbers which contains some
combinatorial polynomials.
"""
from sympy.core import Rational
from sympy.core.function import Function, ArgumentIndexError
from sympy.core.singleton import S
from sympy.core.symbol import D... |
a34db0288d22d90883b29ddefc8dd5d322db25e3b92f3b9125e05f73098d21aa | from sympy import (symbols, Symbol, nan, oo, zoo, I, sinh, sin, pi, atan,
acos, Rational, sqrt, asin, acot, coth, E, S, tan, tanh, cos,
cosh, atan2, exp, log, asinh, acoth, atanh, O, cancel, Matrix, re, im,
Float, Pow, gcd, sec, csc, cot, diff, simplify, Heaviside, arg,
conjugate, series... |
fb2254711b34ef6aff93b8738b2e5ff61b5199b6324e7558f9e0476a455a8af5 | from sympy import (
Symbol, Dummy, gamma, I, oo, nan, zoo, factorial, sqrt, Rational,
multigamma, log, polygamma, digamma, trigamma, EulerGamma, pi, uppergamma, S, expand_func,
loggamma, sin, cos, O, lowergamma, exp, erf, erfc, exp_polar, harmonic,
zeta, conjugate, Ei, im, re, tanh, Abs)
from sympy.cor... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.