hash stringlengths 64 64 | content stringlengths 0 1.51M |
|---|---|
0ecee53f7ed1dfa8ffe6209bd85bb36b94fd238d0c13245c7e264d84486991d4 | import itertools
from collections.abc import Iterable
from sympy import S, Tuple, diff, Basic
from sympy.core.sympify import _sympify
from sympy.tensor.array.ndim_array import NDimArray
from sympy.tensor.array.dense_ndim_array import DenseNDimArray, ImmutableDenseNDimArray
from sympy.tensor.array.sparse_ndim_array im... |
f312f872501915c1a3ead50e8c5d048c513aa7b9cc74cfc354b41d224ee8cdba | from sympy import Basic
from sympy import S
from sympy.core.expr import Expr
from sympy.core.numbers import Integer
from sympy.core.sympify import sympify
from sympy.core.kind import Kind, NumberKind
from sympy.core.compatibility import SYMPY_INTS
from sympy.printing.defaults import Printable
import itertools
from col... |
3e5ad560fd9d934ee4ff1961b9778427c79cc58a8d86aa7dc0757609c592de05 | import random
from sympy.combinatorics import Permutation
from sympy.combinatorics.permutations import _af_invert
from sympy.testing.pytest import raises
from sympy import symbols, sin, exp, log, cos, transpose, adjoint, conjugate, diff
from sympy.tensor.array import Array, ImmutableDenseNDimArray, ImmutableSparseNDi... |
dad013e9bfdff1be982340eefc1ba1f5dd64411dfacc06746c89329b6960e78d | from typing import Tuple as tTuple
from sympy.core.logic import FuzzyBool
from functools import wraps, reduce
import collections
from sympy.core import S, Symbol, Integer, Basic, Expr, Mul, Add
from sympy.core.decorators import call_highest_priority
from sympy.core.compatibility import SYMPY_INTS, default_sort_key
f... |
7d72525b34bca63d21c7c0adf3adeea4e8fc47475fcd26e8c66a72cd3f2d2ccb | from sympy.functions import adjoint, conjugate, transpose
from sympy.matrices.expressions import MatrixSymbol, Adjoint, trace, Transpose
from sympy.matrices import eye, Matrix
from sympy import symbols, S
from sympy import refine, Q
n, m, l, k, p = symbols('n m l k p', integer=True)
A = MatrixSymbol('A', n, m)
B = Mat... |
59f4ffbcbace92f3ea460da67fb833895b3fe9c2e0d24393105bfe35bd7322fa | from sympy.core.relational import Eq, is_eq
from sympy.core.basic import Basic
from sympy.core.logic import fuzzy_and, fuzzy_bool
from sympy.logic.boolalg import And
from sympy.multipledispatch import dispatch
from sympy.sets.sets import tfn, ProductSet, Interval, FiniteSet, Set
@dispatch(Interval, FiniteSet) # type:... |
6b2e6ccc07487cac310ae4832d6e080e05ad115c3c61478a50b2b590a4f25bda | from sympy import S, Symbol
from sympy.core.logic import fuzzy_and, fuzzy_bool, fuzzy_not, fuzzy_or
from sympy.core.relational import Eq
from sympy.sets.sets import FiniteSet, Interval, Set, Union, ProductSet
from sympy.sets.fancysets import Complexes, Reals, Range, Rationals
from sympy.multipledispatch import dispatch... |
1ef5e893fcdf980b4929306d42e420528a996caf3b423c2ab8bf5315863755c0 | from sympy import (Symbol, Set, Union, Interval, oo, S, sympify, nan,
Max, Min, Float, DisjointUnion,
FiniteSet, Intersection, imageset, I, true, false, ProductSet,
sqrt, Complement, EmptySet, sin, cos, Lambda, ImageSet, pi,
Pow, Contains, Sum, rootof, SymmetricDifference, Piecewise,
Matrix, Range, ... |
56e11a7af4bd44130b5135e542cc8881444127c18ba178959191b48c76619e4a | #!/usr/bin/env python
"""Distutils based setup script for SymPy.
This uses Distutils (https://python.org/sigs/distutils-sig/) the standard
python mechanism for installing packages. Optionally, you can use
Setuptools (https://setuptools.readthedocs.io/en/latest/)
to automatically handle dependencies. For the easiest in... |
8ed3cd2f3c5c87911b7fe90578dbd0bac14fff843c09c1456ddf589a3a32a806 | """
SymPy is a Python library for symbolic mathematics. It aims to become a
full-featured computer algebra system (CAS) while keeping the code as simple
as possible in order to be comprehensible and easily extensible. SymPy is
written entirely in Python. It depends on mpmath, and other external libraries
may be option... |
a3673e10a3c2d896cfa32ed64758a5bc39d4059a8ab7750d0df0f6b1b6bfe9f6 | """
Continuous Random Variables - Prebuilt variables
Contains
========
Arcsin
Benini
Beta
BetaNoncentral
BetaPrime
BoundedPareto
Cauchy
Chi
ChiNoncentral
ChiSquared
Dagum
Erlang
ExGaussian
Exponential
ExponentialPower
FDistribution
FisherZ
Frechet
Gamma
GammaInverse
Gumbel
Gompertz
Kumaraswamy
Laplace
Levy
LogCauchy
L... |
f5dcfa7fb088eee67c0dd8d32b494d90476237a9c5927741f3725c09117322e1 | """
Finite Discrete Random Variables - Prebuilt variable types
Contains
========
FiniteRV
DiscreteUniform
Die
Bernoulli
Coin
Binomial
BetaBinomial
Hypergeometric
Rademacher
IdealSoliton
RobustSoliton
"""
from sympy import (S, sympify, Rational, binomial, cacheit, Integer,
Dummy, Eq, Intersection, ... |
39ab2b5166c173176902019daf27b06ea6090fe41e8f8a85271edaea618aa89b | """
Contains
========
FlorySchulz
Geometric
Hermite
Logarithmic
NegativeBinomial
Poisson
Skellam
YuleSimon
Zeta
"""
from sympy import (Basic, factorial, exp, S, sympify, I, zeta, polylog, log, beta,
hyper, binomial, Piecewise, floor, besseli, sqrt, Sum, Dummy,
Lambda, Eq)
from ... |
41971eb174a0f92def43019a568ced895dbe2ad81a352efbf02011d3422574ee | """
Main Random Variables Module
Defines abstract random variable type.
Contains interfaces for probability space object (PSpace) as well as standard
operators, P, E, sample, density, where, quantile
See Also
========
sympy.stats.crv
sympy.stats.frv
sympy.stats.rv_interface
"""
from functools import singledispatch... |
d6f132bfd5ed86f4aa5e69bd8e00f867a4d6ebf0001d486fbfddae0b609cc12a | from sympy import (Basic, sympify, symbols, Dummy, Lambda, summation,
Piecewise, S, cacheit, Sum, exp, I, Ne, Eq, poly,
series, factorial, And, floor)
from sympy.polys.polyerrors import PolynomialError
from sympy.stats.crv import reduce_rational_inequalities_wrap
from sympy.stats.... |
499b6c67d9ed542abddbc28769e0f71dbdbf59dbab5a3b377c3f5414be4b16d9 | """
Continuous Random Variables Module
See Also
========
sympy.stats.crv_types
sympy.stats.rv
sympy.stats.frv
"""
from sympy import (Interval, Intersection, symbols, sympify, Dummy, nan,
Integral, And, Or, Piecewise, cacheit, integrate, oo, Lambda,
Basic, S, exp, I, FiniteSet, Ne, Eq, Union, poly, se... |
09b92427a32e4c5cc5b3697c188a92f2f7bcf29e02308fe33d2fa5ec0d831fed | """
Finite Discrete Random Variables Module
See Also
========
sympy.stats.frv_types
sympy.stats.rv
sympy.stats.crv
"""
from itertools import product
from sympy import (Basic, Symbol, cacheit, sympify, Mul,
And, Or, Piecewise, Eq, Lambda, exp, I, Dummy, nan,
Sum, Intersection, S)
... |
7b50529062c0e2064cce79a317e7d9be8730aa25180c3f129ef0f655ec124baa | """
Generating and counting primes.
"""
import random
from bisect import bisect
from itertools import count
# Using arrays for sieving instead of lists greatly reduces
# memory consumption
from array import array as _array
from sympy import Function, S
from sympy.core.compatibility import as_int
from .primetest impo... |
9466ae7c51446422a9265a86f6224d765fb12daecd19848a0bc972f40917705e | from sympy.ntheory import sieve, isprime
from sympy.core.power import integer_log
from sympy.core.compatibility import as_int
import random
rgen = random.Random()
#----------------------------------------------------------------------------#
# ... |
bb229becf9dd9dcb131efb7ad653081fb98394f0945fdf245402ad0288fb2f25 | """
Primality testing
"""
from sympy.core.compatibility import as_int
from mpmath.libmp import bitcount as _bitlength
def _int_tuple(*i):
return tuple(int(_) for _ in i)
def is_euler_pseudoprime(n, b):
"""Returns True if n is prime or an Euler pseudoprime to base b, else False.
Euler Pseudoprime : I... |
a98d56046b193285dec29f711f1e5a3f98bf00f2e70dddfd8b9b775b701f06e7 | from sympy.core.numbers import igcd, mod_inverse
from sympy.ntheory.residue_ntheory import _sqrt_mod_prime_power
from sympy.ntheory import isprime
from math import log, sqrt
import random
rgen = random.Random()
class SievePolynomial:
def __init__(self, modified_coeff=[], a=None, b=None):
"""This class den... |
49c1ac5fc98dcf6a98f9b965c963ccf1f848397806831f3d61cb09ecbea77e74 | from collections import defaultdict
from sympy.core import (Basic, S, Add, Mul, Pow, Symbol, sympify,
expand_func, Function, Dummy, Expr, factor_terms,
expand_power_exp, Eq)
from sympy.core.compatibility import iterable, ordered, as_int
from sympy.core.parameters import ... |
f35a171bae990aabaa7ea7a036cbc8d759f4dd00fbe9cef9d12988900e508062 | import bisect
import itertools
import operator
from functools import reduce, singledispatch
from itertools import accumulate
from collections import defaultdict
from sympy import Indexed, IndexedBase, Tuple, Sum, Add, S, Integer, diagonalize_vector, DiagMatrix, ZeroMatrix
from sympy.combinatorics import Permutation
fr... |
4c8ad04b137abcc9098ce1238bbcea83c7f936d52cdd9b9de02a2e61d64dc85c | """
Classes and functions useful for rewriting expressions for optimized code
generation. Some languages (or standards thereof), e.g. C99, offer specialized
math functions for better performance and/or precision.
Using the ``optimize`` function in this module, together with a collection of
rules (represented as instan... |
0fc52f7fd5e8a687c3503b915da983fded00080c19f88bf560c86d1ba4842528 | """
The contents of this file are the return value of
``sympy.assumptions.ask.compute_known_facts``.
Do NOT manually edit this file.
Instead, run ./bin/ask_update.py.
"""
from sympy.core.cache import cacheit
from sympy.logic.boolalg import And
from sympy.assumptions.cnf import Literal
from sympy.assumptions.ask impor... |
a563257e0e2ce6848c4d9fda3a0a6b2d3f198e821b4f31c4f7f5ccec7e03ebeb | from typing import Dict, Callable
from sympy.core import S, Add, Expr, Basic, Mul
from sympy.logic.boolalg import Boolean
from sympy.assumptions import Q, ask # type: ignore
def refine(expr, assumptions=True):
"""
Simplify an expression using assumptions.
Explanation
===========
Unlike :func:`... |
fa8cb3cc55bcd556b992cc93870f83b708185056b05ee26bd6277c6f47619267 | """Module for querying SymPy objects about assumptions."""
from sympy.assumptions.assume import (global_assumptions, Predicate,
AppliedPredicate)
from sympy.core import sympify
from sympy.core.cache import cacheit
from sympy.core.relational import Relational
from sympy.core.kind import BooleanKind
from sympy.l... |
aee01dbc603d1e9f02a0bc30d72ebe6ffd8276db626892c71c1cfaba86094a75 | """A module which implements predicates and assumption context."""
from contextlib import contextmanager
import inspect
from sympy.core.assumptions import ManagedProperties
from sympy.core.symbol import Str
from sympy.core.sympify import _sympify
from sympy.logic.boolalg import Boolean
from sympy.multipledispatch.disp... |
d15ee8b643558531b072ca25f4f877d6ebb069d2d990e9d82065105295a699e3 | """A functions module, includes all the standard functions.
Combinatorial - factorial, fibonacci, harmonic, bernoulli...
Elementary - hyperbolic, trigonometric, exponential, floor and ceiling, sqrt...
Special - gamma, zeta,spherical harmonics...
"""
from sympy.functions.combinatorial.factorials import (factorial, fac... |
eb331532fbd81a8a630baa35f59032e6333ffb5add7d24e20916b601d132a02f | """
A Printer which converts an expression into its LaTeX equivalent.
"""
from typing import Any, Dict
import itertools
from sympy.core import Add, Float, Mod, Mul, Number, S, Symbol
from sympy.core.alphabets import greeks
from sympy.core.containers import Tuple
from sympy.core.function import _coeff_isneg, AppliedU... |
f5c9956ed260557a4fcd14caca31b3d8e79fd1456732d5f33725df81a50b054d | from sympy.concrete.expr_with_limits import AddWithLimits
from sympy.core.add import Add
from sympy.core.basic import Basic
from sympy.core.compatibility import is_sequence
from sympy.core.containers import Tuple
from sympy.core.expr import Expr
from sympy.core.function import diff
from sympy.core.logic import fuzzy_bo... |
866153a25bc3e2a2bd7eb56cc8684a3a6111b74fe26fe0c0f9b0198c82d74d02 | """Base class for all the objects in SymPy"""
from collections import defaultdict
from collections.abc import Mapping
from itertools import chain, zip_longest
from .assumptions import BasicMeta, ManagedProperties
from .cache import cacheit
from .sympify import _sympify, sympify, SympifyError
from .compatibility import... |
84a0a40f245e5e359092663d2e43e932085ba595a561f18f91e38041ed6824de | 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 .... |
774cc14802957d625a454b3b83edb8d35343a7ed6afb9546739040103c9092d0 | """Thread-safe global parameters"""
from .cache import clear_cache
from contextlib import contextmanager
from threading import local
class _global_parameters(local):
"""
Thread-local global parameters.
Explanation
===========
This class generates thread-local container for SymPy's global paramet... |
42ccd65a8ddc259ea8e6f1d0ae1f5af9ab1caa6991b61200b82130e3098e0dcb | from typing import Tuple as tTuple
from collections.abc import Iterable
from functools import reduce
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_arg... |
a29ec5fd4fec553a3031832b471dd4261fa282b526d6107e5888995ff426ec19 | import numbers
import decimal
import fractions
import math
import re as regex
import sys
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... |
b0e0321af376ded04b200a0689e5047b6b2e2cbf88a81a88ae0283db19f0f2b6 | from sympy.core.assumptions import StdFactKB, _assume_defined
from sympy.core.compatibility import is_sequence, ordered
from .basic import Basic, Atom
from .sympify import sympify
from .singleton import S
from .expr import Expr, AtomicExpr
from .cache import cacheit
from .function import FunctionClass
from .kind import... |
9032a1538c4b94b0e0371a168f21fff68b07cc868be1825fe9d232fb11f49a08 | """
Adaptive numerical evaluation of SymPy expressions, using mpmath
for mathematical functions.
"""
from typing import Tuple
import math
import mpmath.libmp as libmp
from mpmath import (
make_mpc, make_mpf, mp, mpc, mpf, nsum, quadts, quadosc, workprec)
from mpmath import inf as mpmath_inf
from mpmath.libmp imp... |
99524209bb9c5e930871b11693af3bb11060f1482c7446c156658ce6383da614 | from collections import defaultdict
from functools import cmp_to_key, reduce
import operator
from .sympify import sympify
from .basic import Basic
from .singleton import S
from .operations import AssocOp, AssocOpDispatcher
from .cache import cacheit
from .logic import fuzzy_not, _fuzzy_group
from .expr import Expr
fro... |
23c05785f1bb626f7fefe669f35d98d1d026dc7c03ee2268019067c093051529 | """py.test hacks to support XFAIL/XPASS"""
import sys
import functools
import os
import contextlib
import warnings
from sympy.utilities.exceptions import SymPyDeprecationWarning
ON_TRAVIS = os.getenv('TRAVIS_BUILD_NUMBER', None)
try:
import pytest
USE_PYTEST = getattr(sys, '_running_pytest', False)
except I... |
54c35709149aca28104fa6b772f7f933f33ec1d57e2928a5fc96c098772e5107 | """A module to manipulate symbolic objects with indices including tensors
"""
from .indexed import IndexedBase, Idx, Indexed
from .index_methods import get_contraction_structure, get_indices
from .functions import shape
from .array import (MutableDenseNDimArray, ImmutableDenseNDimArray,
MutableSparseNDimArray, Imm... |
114d63d29c42aa84f2cf9881eaa11f4e688cc56eb17ca028ba9649e08c7a4c8b | from collections.abc import Iterable
from functools import singledispatch
from sympy import Expr, S, Mul, sympify
from sympy.core.parameters import global_parameters
class TensorProduct(Expr):
"""
Generic class for tensor products.
"""
is_number = False
def __new__(cls, *args, **kwargs):
... |
58a9771e3bb6a906aae1fdbca40bfba85277c25d7a3dd5f1c02d0de8888ce5e6 | """
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.decorators import s... |
ebf93e020d83fd710e7e35c6f5e8405f67fa23392873dbbd9e36b70e1bad8dba | import copy
from sympy.core.function import expand_mul
from sympy.functions.elementary.miscellaneous import Min, sqrt
from sympy.functions.elementary.complexes import sign
from .common import NonSquareMatrixError, NonPositiveDefiniteMatrixError
from .utilities import _get_intermediate_simp, _iszero
from .determinant ... |
7a8e5c60045bf64333a8217e05d7628d937b171aa946199ef21d544b4f9354bb | """A module that handles matrices.
Includes functions for fast creating matrices like zero, one/eye, random
matrix, etc.
"""
from .common import ShapeError, NonSquareMatrixError, MatrixKind
from .dense import (
GramSchmidt, casoratian, diag, eye, hessian, jordan_cell,
list2numpy, matrix2numpy, matrix_multiply_... |
1b3ccf5277f86de3e4334fd5c2461d13e27e3d3ea82cde9454ae09f66e0e6347 | """
Basic methods common to all matrices to be used
when creating more advanced matrices (e.g., matrices over rings,
etc.).
"""
from collections import defaultdict
from collections.abc import Iterable
from inspect import isfunction
from functools import reduce
from sympy.core.logic import FuzzyBool
from sympy.assumpt... |
6a94ac457894496a0cc52adb9e4043d05140764ecaae5a9d569a7ea3fae12d1a | 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.kind import _NumberKind, NumberKind, UndefinedKind
f... |
e7567a85282a912dedd8e3d6e3027cbb6d5c7e0759fcffc34234ccf591144aab | 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, sympify_method_args,
sympify_return)
from sympy.co... |
2038db17f02f34b14c74fd41066527ae77508c84e2a6cf2d8c5e574e432319d7 | from sympy import S
from sympy.core.basic import Basic
from sympy.core.containers import Tuple
from sympy.core.function import Lambda
from sympy.core.logic import fuzzy_bool
from sympy.core.relational import Eq
from sympy.core.symbol import Dummy
from sympy.core.sympify import _sympify
from sympy.logic.boolalg import A... |
d323f9f1fccca04cf50ec1f7d5b10a664ee45fe0ede1f94b64d8c23af1d9a60a | 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, harmonic, Function)
from sympy.matrices import Matrix
from sympy.stats import (DiscreteUniform, Die, Berno... |
84e33f522c75126c1fdf92bf02b37042b385a3433a097cced249ee4919127da5 | 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... |
b060be72e7c06a824292e12e72878f4ed4c2048626f110c55596a640707fc52a | 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, atan, sinh, cosh,
besseli, floor, exp... |
59ca10e990470bbfc29cade8838bda602b99b5bcb3f4b2814536f2bf2ad4c2f1 | from functools import singledispatch
from sympy.external import import_module
from sympy.stats.crv_types import BetaDistribution, ChiSquaredDistribution, ExponentialDistribution, GammaDistribution, \
LogNormalDistribution, NormalDistribution, ParetoDistribution, UniformDistribution
from sympy.stats.drv_types impor... |
ef5a516bc14bed04a3698c5d530901d9339c877d7897c39f6e2426f8b872b23d | from functools import singledispatch
from sympy import Dummy, lambdify, exp
from sympy.external import import_module
from sympy.stats import DiscreteDistributionHandmade
from sympy.stats.crv import SingleContinuousDistribution
from sympy.stats.crv_types import ChiSquaredDistribution, ExponentialDistribution, GammaDist... |
149df35a1944c39ae5ff168948f89214ad958bf47db9810a6fc5bc43acc26bca | from functools import singledispatch
from sympy.external import import_module
from sympy.stats.crv_types import BetaDistribution, CauchyDistribution, ChiSquaredDistribution, ExponentialDistribution, \
GammaDistribution, LogNormalDistribution, NormalDistribution, ParetoDistribution, UniformDistribution, \
Gaussi... |
bb66e000713944dbb16a4ba33c3de4fd899bdf8dfd44fe318a0f9b52bda8acaf | from sympy import S, Rational
from sympy.external import import_module
from sympy.stats import Binomial, sample, Die, FiniteRV, DiscreteUniform, Bernoulli, BetaBinomial, Hypergeometric, \
Rademacher
from sympy.testing.pytest import skip, ignore_warnings, raises
def test_given_sample():
X = Die('X', 6)
scip... |
29d19016f76f2f5e472a76085d327b40fb77f9bae078242388baca198d0d5766 | from sympy import exp, Interval, oo, Symbol
from sympy.external import import_module
from sympy.stats import Beta, Chi, Normal, Gamma, Exponential, LogNormal, Pareto, ChiSquared, Uniform, sample, \
BetaPrime, Cauchy, GammaInverse, GaussianInverse, StudentT, Weibull, density, ContinuousRV
from sympy.testing.pytest i... |
a00c8c89ffd807ee543f78f5eb6c1ff119481b57c850beada17618ab1f23bdb8 | from sympy import S, Symbol
from sympy.external import import_module
from sympy.stats import Geometric, Poisson, Zeta, sample, Skellam, DiscreteRV, Logarithmic, NegativeBinomial, YuleSimon
from sympy.testing.pytest import skip, ignore_warnings, raises, slow
def test_sample_numpy():
distribs_numpy = [
Geom... |
904ae09ce84e62f0ccf9eae27c29bccbc904c2ce2077319967bcb0edae5df717 | from sympy import Sieve, sieve, Symbol, S, limit, I, zoo, nan, Rational
from sympy.ntheory import isprime, totient, mobius, randprime, nextprime, prevprime, \
primerange, primepi, prime, primorial, composite, compositepi, reduced_totient
from sympy.ntheory.generate import cycle_length
from sympy.ntheory.primetest ... |
a07fe2f7e5b3c1a3188b021c13d5099a79faf541b160ec64b56ff0cbeea35274 | from sympy import log, exp, cos, Symbol, Pow, sin, MatrixSymbol, sinc
from sympy.assumptions import assuming, Q
from sympy.printing import ccode
from sympy.codegen.matrix_nodes import MatrixSolve
from sympy.codegen.cfunctions import log2, exp2, expm1, log1p
from sympy.codegen.numpy_nodes import logaddexp, logaddexp2
fr... |
e103f58e77f398e7a2a66760cb65543f68ef05f999e22e88b8d8009641d29b53 | from sympy import (
symbols, IndexedBase, Identity, cos, Inverse, tensorcontraction,
permutedims, tensorproduct, ZeroMatrix)
from sympy.codegen.array_utils import (
CodegenArrayContraction, CodegenArrayTensorProduct, CodegenArrayDiagonal,
CodegenArrayPermuteDims, CodegenArrayElementwiseAdd, _codegen_arr... |
c2f14d1527f44b87a06d8ed1130d15d00342d370ae89153d3cb99d8b5e957c7a | from sympy.assumptions import Predicate
from sympy.multipledispatch import Dispatcher
class PrimePredicate(Predicate):
"""
Prime number predicate.
Explanation
===========
``ask(Q.prime(x))`` is true iff ``x`` is a natural number greater
than 1 that has no positive divisors other than ``1`` a... |
1edce9839a8a00fe961dc584446ba2c4f42cfdbb820cfb570887baf6ca03d115 | from sympy.assumptions import Predicate
from sympy.multipledispatch import Dispatcher
class CommutativePredicate(Predicate):
"""
Commutative predicate.
Explanation
===========
``ask(Q.commutative(x))`` is true iff ``x`` commutes with any other
object with respect to multiplication operation.... |
8c3c61af69dd0e369d3600c2f1009b1bf63374f6c61adf7eb57d6a859b1e67e7 | from sympy.assumptions import Predicate
from sympy.multipledispatch import Dispatcher
class SquarePredicate(Predicate):
"""
Square matrix predicate.
Explanation
===========
``Q.square(x)`` is true iff ``x`` is a square matrix. A square matrix
is a matrix with the same number of rows and colum... |
062c44b0fdad63429266bb4596e4b1ba35809a532dc3e4f8e8d2fe2692d09a6d | from sympy.assumptions import Predicate
from sympy.multipledispatch import Dispatcher
class NegativePredicate(Predicate):
r"""
Negative number predicate.
Explanation
===========
``Q.negative(x)`` is true iff ``x`` is a real number and :math:`x < 0`, that is,
it is in the interval :math:`(-\i... |
96f8c07cf773d0c0e34f18eecdb052181728d8e9a96518868b1486d286a2662d | """
Multipledispatch handlers for ``Predicate`` are implemented here.
Handlers in this module are not directly imported to other modules in
order to avoid circular import problem.
"""
from .common import (AskHandler, CommonHandler,
test_closed_group)
__all__ = [
'AskHandler', 'CommonHandler',
'test_closed... |
0346dad29a6eaf38dc386583d1c478388922450510f6c0f3cb46a22fca72f769 | """
Handlers for keys related to number theory: prime, even, odd, etc.
"""
from sympy.assumptions import Q, ask
from sympy.core import Add, Basic, Expr, Float, Mul, Pow, S
from sympy.core.numbers import (ImaginaryUnit, Infinity, Integer, NegativeInfinity,
NumberSymbol, Rational)
from sympy.functions import Abs, im... |
25b9e85bd07ec6059d15fc099d2d1c09981c8a99deb07041732757a3620d578c | """
This module defines base class for handlers and some core handlers:
``Q.commutative`` and ``Q.is_true``.
"""
from sympy.assumptions import Q, ask, AppliedPredicate
from sympy.core import Basic, Symbol
from sympy.core.logic import _fuzzy_group
from sympy.core.numbers import NaN, Number
from sympy.logic.boolalg impo... |
56190651573ba7a6e4c35595c48b1ebde5c4ada2bb96a86e488ae86174918881 | """
This module contains query handlers responsible for Matrices queries:
Square, Symmetric, Invertible etc.
"""
from sympy.logic.boolalg import conjuncts
from sympy.assumptions import Q, ask
from sympy.assumptions.handlers import test_closed_group
from sympy.matrices import MatrixBase
from sympy.matrices.expressions ... |
4e5a75885f566cd8648ea2b9a15d9e1ce62c1775bc1af6c8534f12428cfcef06 | """
Handlers related to order relations: positive, negative, etc.
"""
from sympy.assumptions import Q, ask
from sympy.core import Add, Basic, Expr, Mul, Pow
from sympy.core.logic import fuzzy_not, fuzzy_and, fuzzy_or
from sympy.core.numbers import ImaginaryUnit, NaN
from sympy.functions import Abs, acos, acot, asin, a... |
4b1bb53084d0a1743c9a4c968ebf64084b37610e5ede5998467333e3b1b3dfda | """
Handlers for predicates related to set membership: integer, rational, etc.
"""
from sympy.assumptions import Q, ask
from sympy.core import Add, Basic, Expr, Mul, Pow
from sympy.core.numbers import (AlgebraicNumber, ComplexInfinity, Exp1, Float,
GoldenRatio, ImaginaryUnit, Infinity, Integer, NaN, NegativeInfini... |
ffd41c2e345ca5afd7eb91091d8917d633c254b81a120e1170f159724c5f8907 | from sympy import (Abs, exp, Expr, I, pi, Q, Rational, refine, S, sqrt,
atan, atan2, nan, Symbol, re, im, sign)
from sympy.abc import w, x, y, z
from sympy.core.relational import Eq, Ne
from sympy.functions.elementary.piecewise import Piecewise
from sympy.matrices.expressions.matexpr import MatrixSym... |
ec2352c79fa52679b02f91e34ab0fd70c92987d7c5c7e78bde5a5055f2f807b6 | from sympy.abc import t, w, x, y, z, n, k, m, p, i
from sympy.assumptions import (ask, AssumptionsContext, Q, register_handler,
remove_handler)
from sympy.assumptions.assume import assuming, global_assumptions, Predicate
from sympy.assumptions.ask import compute_known_facts, single_fact_lookup
from sympy.assump... |
bfccc74308c7a6b0c90aee0b0d7934f8df8a2876ff837c33ebd55051e4cfd495 | """
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... |
762a6ab7e252cf5c3bededfaa01ddde55596c99ba22d3df61097fea2bb5259aa | 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... |
ba4775b519e0acac508258729574d4c39fb79f0902dd9550c9f1cc9adc5a39f4 | from sympy import Basic, Expr
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, is_eq
from sy... |
6874ec09dc7ef2e0ad99708dd78024e87552959acc406b4be1a84b197da70327 | 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... |
b1c70fbccc4fb674316a4d5dbc1d9a5eb1c4448c95fffdbf91173a5681079723 | import string
from sympy import (
Symbol, symbols, Dummy, S, Sum, Rational, oo, pi, I, floor, limit,
expand_func, diff, EulerGamma, cancel, re, im, Product, carmichael,
TribonacciConstant)
from sympy.functions import (
bernoulli, harmonic, bell, fibonacci, tribonacci, lucas, euler, catalan,
genocch... |
d4c7a5b242d0c5689ef7531720c84cba19edada04e168a260ec213003e48d3f6 | from sympy import (
symbols, log, ln, Float, nan, oo, zoo, I, pi, E, exp, Symbol,
LambertW, sqrt, Rational, expand_log, S, sign,
adjoint, conjugate, transpose, O, refine,
sin, cos, sinh, cosh, tanh, exp_polar, re, simplify,
AccumBounds, MatrixSymbol, Pow, gcd, Sum, Product)
from sympy.core.parameter... |
0e948202e40946e68da421724757309e39e1f1538f62e4a8ca512b84828413d9 | from sympy import (
Abs, And, Derivative, Dummy, Eq, Float, Function, Gt, I, Integral,
LambertW, Lt, Matrix, Or, Poly, Q, Rational, S, Symbol, Ne,
Wild, acos, asin, atan, atanh, binomial, cos, cosh, diff, erf, erfinv, erfc,
erfcinv, exp, im, log, pi, re, sec, sin,
sinh, solve, solve_linear, sqrt, ss... |
f9c966b5d9bf6937219c0d8cd3111ced251f796712b6d1b815643536b52203e6 | from sympy import (Symbol, S, exp, log, sqrt, oo, E, zoo, pi, tan, sin, cos,
cot, sec, csc, Abs, symbols, I, re, simplify,
expint, Rational)
from sympy.calculus.util import (function_range, continuous_domain, not_empty_in,
periodicity, lcim, AccumBo... |
35f6c329ebbcd9851073d55d52929ba143bff332216fa7f61d27c55b3d1db761 | import itertools
from sympy.core import S
from sympy.core.containers import Tuple
from sympy.core.function import _coeff_isneg
from sympy.core.mul import Mul
from sympy.core.numbers import Number, Rational
from sympy.core.power import Pow
from sympy.core.symbol import Symbol
from sympy.core.sympify import SympifyError... |
79d5bdea7367825f6f5ac7978d2cea4a03ff615b526ef9c2c280e5b7c427c6e5 | from sympy import (Add, Abs, Catalan, cos, Derivative, E, EulerGamma, exp,
factorial, factorial2, Function, GoldenRatio, TribonacciConstant, I,
Integer, Integral, Interval, Lambda, Limit, Matrix, nan, O, oo, pi, Pow,
Rational, Float, Rel, S, sin, SparseMatrix, sqrt, summation, Sum, Symbol,
symbols, Wild... |
ffa63c5717168f96a1c41b94cbd8731786402f938d70900338e1699569b2a9a9 | from sympy.tensor.toperators import PartialDerivative
from sympy import (
Abs, Chi, Ci, CosineTransform, Dict, Ei, Eq, FallingFactorial,
FiniteSet, Float, FourierTransform, Function, Indexed, IndexedBase, Integral,
Interval, InverseCosineTransform, InverseFourierTransform, Derivative,
InverseLaplaceTra... |
82eb01d2da4e3f44d6217daa2fa65816ef20db7e7bb103814ab0de860be0d2c3 | # -*- coding: utf-8 -*-
from sympy import (
Add, And, Basic, Derivative, Dict, Eq, Equivalent, FF,
FiniteSet, Function, Ge, Gt, I, Implies, Integral, SingularityFunction,
Lambda, Le, Limit, Lt, Matrix, Mul, Nand, Ne, Nor, Not, O, Or,
Pow, Product, QQ, RR, Rational, Ray, rootof, RootSum, S,
Segment, ... |
e0a808d22d4d5dad20c2200e5f93a0b762307e69096dd326a063887787b5ecce | """Test whether all elements of cls.args are instances of Basic. """
# NOTE: keep tests sorted by (module, class name) key. If a class can't
# be instantiated, add it here anyway with @SKIP("abstract class) (see
# e.g. Function).
import os
import re
from sympy import (Basic, S, symbols, sqrt, sin, oo, Interval, exp,... |
9211f0617a39448b21963825c7828b90865595229f87c85e513efd6e6c812808 | import numbers as nums
import decimal
from sympy import (Rational, Symbol, Float, I, sqrt, cbrt, oo, nan, pi, E,
Integer, S, factorial, Catalan, EulerGamma, GoldenRatio,
TribonacciConstant, cos, exp,
Number, zoo, log, Mul, Pow, Tuple, latex, Gt, Lt, Ge, Le,
... |
607f845e6c88cce0cea87f56c3187aba11aaca22961a1c3980978e186efb2c28 | from sympy import (Abs, Add, atan, ceiling, cos, E, Eq, exp, factor,
factorial, fibonacci, floor, Function, GoldenRatio, I, Integral,
integrate, log, Mul, N, oo, pi, Pow, product, Product, tan,
Rational, S, Sum, simplify, sin, sqrt, sstr, sympify, Symbol, Max, nfloat, cosh, acosh, acos)
from sympy.core.numb... |
5c386eb13ec41daeff7ac00c29ba178c16bd42b5c38410d164b4207cd185629b | from sympy import (abc, Add, cos, collect, Derivative, diff, exp, Float, Function,
I, Integer, log, Mul, oo, Poly, Rational, S, sin, sqrt, Symbol, symbols,
Wild, pi, meijerg, Sum
)
from sympy.testing.pytest import XFAIL
def test_symbol():
x = Symbol('x')
a, b, c, p, q = map(Wild, 'abcpq')
e = x
... |
7a403b1dfe6fe57555ed9fa10c255459191d85303bb753faed47a9849feb10b2 | from sympy.testing.pytest import raises, XFAIL
from sympy.external import import_module
from sympy import (
Symbol, Mul, Add, Abs, sin, asin, cos, Pow, csc, sec,
Limit, oo, Derivative, Integral, factorial, sqrt, root,
conjugate, StrictLessThan, LessThan, StrictGreaterThan,
GreaterThan, Sum, Product, E,... |
cd3cccef0178b64479878c2be61c66fa2f6409b6e707e5a21289f685fcfea515 | # Ported from latex2sympy by @augustt198
# https://github.com/augustt198/latex2sympy
# See license in LICENSE.txt
import sympy
from sympy.external import import_module
from sympy.printing.str import StrPrinter
from sympy.physics.quantum.state import Bra, Ket
from .errors import LaTeXParsingError
LaTeXParser = LaTeX... |
caf18e9598ec0c0955def1544dea3bf0298c966bdd6d0c4bd36d7bc8739c59a3 |
# encoding: utf-8
# *** GENERATED BY `setup.py antlr`, DO NOT EDIT BY HAND ***
#
# Generated from ../LaTeX.g4, derived from latex2sympy
# latex2sympy is licensed under the MIT license
# https://github.com/augustt198/latex2sympy/blob/master/LICENSE.txt
#
# Generated with antlr4
# antlr4 is licensed under th... |
5096da4c9f14859b9dab9e2bf733120be47dbd518867e55d7ca31492b914d11e |
# encoding: utf-8
# *** GENERATED BY `setup.py antlr`, DO NOT EDIT BY HAND ***
#
# Generated from ../LaTeX.g4, derived from latex2sympy
# latex2sympy is licensed under the MIT license
# https://github.com/augustt198/latex2sympy/blob/master/LICENSE.txt
#
# Generated with antlr4
# antlr4 is licensed under th... |
a987fec2ff25a870d9c6c4bcf0f62cfde1272ce7bea834387ba2ce08933198ab | """Quantum mechanical angular momemtum."""
from sympy import (Add, binomial, cos, exp, Expr, factorial, I, Integer, Mul,
pi, Rational, S, sin, simplify, sqrt, Sum, symbols, sympify,
Tuple, Dummy)
from sympy.matrices import zeros
from sympy.printing.pretty.stringpict import prettyF... |
4535887b8cd1bbc654e7206cfe5e16b5ab8f5a4495881eab7aef979e2b1b2c82 | from sympy import cos, exp, expand, I, Matrix, pi, S, sin, sqrt, Sum, symbols, Rational
from sympy.abc import alpha, beta, gamma, j, m
from sympy.physics.quantum import hbar, represent, Commutator, InnerProduct
from sympy.physics.quantum.qapply import qapply
from sympy.physics.quantum.tensorproduct import TensorProduct... |
6b02e04a426466910473daccb1bf132ca5d039cea9bcda20c7ebd0927f6d4fe3 | from sympy import symbols, pi, sin, cos, Float, ImmutableMatrix as Matrix
from sympy.physics.vector import ReferenceFrame, Vector, dynamicsymbols, dot
from sympy.abc import x, y, z
from sympy.testing.pytest import raises
Vector.simp = True
A = ReferenceFrame('A')
def test_Vector():
assert A.x != A.y
assert ... |
70c9e18440525efbec04c265ecd5262f2d5d58a8a86cac9222744704415997c0 | from sympy import sin, cos, symbols, pi, Float, ImmutableMatrix as Matrix
from sympy.physics.vector import ReferenceFrame, Vector, dynamicsymbols, outer
from sympy.physics.vector.dyadic import _check_dyadic
from sympy.testing.pytest import raises
Vector.simp = True
A = ReferenceFrame('A')
def test_dyadic():
d1 =... |
7de12f9ed17683179987d4e2f888de76795f4200f59e87b3755ac84192c2f2a0 | from sympy import Basic
from sympy import S
from sympy.core.expr import Expr
from sympy.core.numbers import Integer
from sympy.core.sympify import sympify
from sympy.core.kind import Kind, NumberKind, UndefinedKind
from sympy.core.compatibility import SYMPY_INTS
from sympy.printing.defaults import Printable
import ite... |
69dd942ca6d971834d6ea79038f58cfb0b68c807e440d8ea9d4b1659bfaafe0c | from sympy import Expr, ImmutableDenseNDimArray, S
from sympy.core.sympify import _sympify
class ZeroArray(Expr):
"""
Symbolic array of zeros. Equivalent to ``ZeroMatrix`` for matrices.
"""
def __new__(cls, *shape):
if len(shape) == 0:
return S.Zero
shape = map(_sympify, s... |
35ea65b0972ebc49a7ff4158351aacaf3c7100e69ac1303e612f5ef5d6d2abd4 | import operator
from functools import reduce, singledispatch
from sympy import Expr, Transpose, Identity, MatrixSymbol, S
from sympy.codegen.array_utils import CodegenArrayElementwiseAdd, CodegenArrayPermuteDims, CodegenArrayContraction, \
get_shape, CodegenArrayTensorProduct
from sympy.combinatorics.permutations ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.