hash stringlengths 64 64 | content stringlengths 0 1.51M |
|---|---|
dadad15164b93d3aa54fb4ff2922246d43000284fed709a3e79ea6a33497fa69 | """
A MathML printer.
"""
from typing import Any, Dict
from sympy import sympify, S, Mul
from sympy.core.compatibility import default_sort_key
from sympy.core.function import _coeff_isneg
from sympy.printing.conventions import split_super_sub, requires_partial
from sympy.printing.precedence import \
precedence_tr... |
744e2eb51c6cb1b8a0336da549fb9f7ff3f4b3274074e36b8b2b4e80f96f79da | from typing import Any, Dict, Set, Tuple
from functools import wraps
from sympy.core import Add, Expr, Mul, Pow, S, sympify, Float
from sympy.core.basic import Basic
from sympy.core.compatibility import default_sort_key
from sympy.core.function import Lambda
from sympy.core.mul import _keep_coeff
from sympy.core.symb... |
abab6d09ec82cbc4a60f8c1100402805e2bc08316b032c33fcf3ec4e6a7dc06e | """
A Printer for generating executable code.
The most important function here is srepr that returns a string so that the
relation eval(srepr(expr))=expr holds in an appropriate environment.
"""
from typing import Any, Dict
from sympy.core.function import AppliedUndef
from sympy.core.mul import Mul
from mpmath.libmp... |
238adaa8748f7104b821b936c71e9b4c3bd6f20ae19231f020ad59bc12aab594 | from typing import Set
from sympy.core import Basic, S
from sympy.core.function import _coeff_isneg, Lambda
from sympy.printing.codeprinter import CodePrinter
from sympy.printing.precedence import precedence
from functools import reduce
known_functions = {
'Abs': 'abs',
'sin': 'sin',
'cos': 'cos',
'ta... |
31bf64f6367e1c03547364bb637188af87c1f4f5a73c82eb8ddc5a58cb2ca649 | """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... |
6c2059aa49b735b2f125f7d710593127b881119cf423472c9f1221eb0ae033cf | 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 .... |
855aa8c2e2db73cf08b2f86278362eab3c2f7b8224c5d9f3e482fe2b407ba100 | """
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... |
a4cb023809d54f9ede64cea6f8c44376aaba741f886278a9805b7eb408c003f9 | """Core module. Provides the basic operations needed in sympy.
"""
from .sympify import sympify, SympifyError
from .cache import cacheit
from .assumptions import assumptions, check_assumptions, failing_assumptions, common_assumptions
from .basic import Basic, Atom, preorder_traversal
from .singleton import S
from .exp... |
d301d8dddf363fcf4338986b9d55e9c00dc75d7e12c06c60ba55a2478fa1e1c4 | """
Module to efficiently partition SymPy objects.
This system is introduced because class of SymPy object does not always
represent the mathematical classification of the entity. For example,
``Integral(1, x)`` and ``Integral(Matrix([1,2]), x)`` are both instance
of ``Integral`` class. However the former is number an... |
87d8105b602c3def672def2ac8b45254b69f4197567342a57ad72a1cb2397121 | from collections import defaultdict
from functools import cmp_to_key, reduce
from operator import attrgetter
from .basic import Basic
from .compatibility import is_sequence
from .parameters import global_parameters
from .logic import _fuzzy_group, fuzzy_or, fuzzy_not
from .singleton import S
from .operations import Ass... |
2e7706c6903394c2e448253d4dfb7b837f2a11d386590f68f7fbaafdb8cf9937 | 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... |
7a3331746d5811721cd022dc8d970ae374245b5d34aaae01189fcc6d7d9326ae | from typing import Dict, Union, Type
from sympy.utilities.exceptions import SymPyDeprecationWarning
from .basic import S, Atom
from .compatibility import ordered
from .basic import Basic
from .evalf import EvalfMixin
from .function import AppliedUndef
from .sympify import _sympify, SympifyError
from .parameters import... |
2d03fc0258ef7e9bcf884fead354b9288d641542c0aec6582a764997aacb9b4a | 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... |
95f63d0f7861a28e7fd511cb4839ba0a9981527fe1720ce60531343d41a89ae5 | from sympy.core.numbers import nan
from .function import Function
from .kind import NumberKind
class Mod(Function):
"""Represents a modulo operation on symbolic expressions.
Parameters
==========
p : Expr
Dividend.
q : Expr
Divisor.
Notes
=====
The convention used ... |
796f07c88999e655c542f3c66eafdb69b0c82ee338f5e8ec9fd9449684f9801d | 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... |
713d2dec519b0c899ba1baa6d4ba9d38a593c1d2db54cc189b961bbbe8856674 | from sympy import Expr, Add, Mul, Pow, sympify, Matrix, Tuple
from sympy.utilities import default_sort_key
def _is_scalar(e):
""" Helper method used in Tr"""
# sympify to set proper attributes
e = sympify(e)
if isinstance(e, Expr):
if (e.is_Integer or e.is_Float or
e.is_Rational o... |
bad95522933ec7b1c5f5376429597fff7542339210eb758fad7856c927bdb36f | 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... |
adb5aa06054d4fad0711b87551115d029b5eff1f31a86024fdf564f4afdfd795 | """User-friendly public interface to polynomial functions. """
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.compatibility import iterable, ordered
from sym... |
16636a925345411d56ad062d3f6afb8f2a70d8841a74d2863f5e046946b152a2 | """
Stub module to expose DomainMatrix which has now moved to
sympy.polys.matrices package. It should now be imported as:
>>> from sympy.polys.matrices import DomainMatrix
This module might be removed in future.
"""
from sympy.polys.matrices.domainmatrix import DomainMatrix
__all__ = ['DomainMatrix']
|
2a844cd98e596d289d58c5de4547892920486c962fc366e54cd4df918da4ad38 | """Sparse polynomial rings. """
from typing import Any, Dict
from operator import add, mul, lt, le, gt, ge
from functools import reduce
from types import GeneratorType
from sympy.core.compatibility import is_sequence
from sympy.core.expr import Expr
from sympy.core.numbers import igcd, oo
from sympy.core.symbol imp... |
017cc8599fb68934b58d40ccd135fd8395037d4909f50c3b09be15e1121ee1ba | """ 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... |
429a5149bc0629772e67cf9660a64f5a57dd22ca2974cc09d698dfbfdd88a466 | """ SymPy interface to Unification engine
See sympy.unify for module level docstring
See sympy.unify.core for algorithmic docstring """
from sympy.core import Basic, Add, Mul, Pow
from sympy.core.operations import AssocOp, LatticeOp
from sympy.matrices import MatAdd, MatMul, MatrixExpr
from sympy.sets.sets import Uni... |
e436ef312069509a68aea164bf401666e792f0c619134a4470bcf0e4511500f8 | """ Functions to support rewriting of SymPy expressions """
from sympy import Expr
from sympy.assumptions import ask
from sympy.strategies.tools import subs
from sympy.unify.usympy import rebuild, unify
def rewriterule(source, target, variables=(), condition=None, assume=None):
""" Rewrite rule.
Transform ex... |
c7422f2de48b8ff659bf0e6376ca3dc4237c4fb6e2b04c7e35d1b31092a3c071 | """
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... |
e4629fa57636669fad79fae9b52d5f35745e1f96d796643f3525b1945d2127a5 | """
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... |
baf9badb169f815211bcdb8d79e973eb9ed67127e4699623d35b9924dbcacb00 | 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... |
8e99861306866ecda8020e27736f034b157f8ec7b1965712ffd0f9bb47c1f1fc | """A module that handles matrices.
Includes functions for fast creating matrices like zero, one/eye, random
matrix, etc.
"""
from .common import ShapeError, NonSquareMatrixError
from .dense import (
GramSchmidt, casoratian, diag, eye, hessian, jordan_cell,
list2numpy, matrix2numpy, matrix_multiply_elementwise,... |
909e6731f3d0da795d2c6b454fe398ee46f042f9029df60fe0f3e40efdf4aa90 | 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.mul import Mul
from sympy.core.power import Pow
from... |
804858ebc6434b971df2117f6407309b36bfd47cb4bfddae00f0babffd84a8f1 | 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.... |
446410fe8ff3a980ee87956a101ca201a9d655cbe900e5983311e490c9a3b84b | 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... |
6660ef6070daed01446cbf5e737f63e79d42bcfa7843723aa754dbec08fe975a | 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.external import import_module
from sympy.matrices import Matrix
from sympy.... |
3469a54c0ed804e946dc201698452642b0c3f5eaa643db25629d168704f01bff | from sympy import (symbols, pi, oo, S, exp, sqrt, besselk, Indexed, Sum, simplify,
Rational, factorial, gamma, Piecewise, Eq, Product, Interval,
IndexedBase, RisingFactorial, polar_lift, ProductSet, Range)
from sympy.core.numbers import comp
from sympy.integrals.integrals import in... |
8694737098f9ff9d05b18646058018151b9718a6a43e6ac624b6123830490951 | from sympy import (S, symbols, FiniteSet, Eq, Matrix, MatrixSymbol, Float, And,
ImmutableMatrix, Ne, Lt, Le, Gt, Ge, exp, Not, Rational, Lambda, erf,
Piecewise, factorial, Interval, oo, Contains, sqrt, pi, ceiling,
gamma, lowergamma, Sum, Range, Tuple, ImmutableD... |
a34e962dd82d5f1faeaf7adb855e14261afd21dac7dafb34f56dd534b5521996 | from sympy import exp, S, sqrt, pi, symbols, Product, gamma, Dummy
from sympy.matrices import Determinant, Matrix, Trace, MatrixSymbol, MatrixSet
from sympy.stats import density, sample
from sympy.stats.matrix_distributions import (MatrixGammaDistribution,
MatrixGamma, MatrixPSpace, Wishart, MatrixNorma... |
fd7171db4b27a0a857c0ae942fc0fa8a79a965e743039ab1293274aeef3aeaf2 | 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... |
174556b023b6954bb375e7abcd90b145ab21b4f27dfa4ff127d1d23c0df03d26 | 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... |
56ccf593d35cb21d6147726c46478c16b99c21a8a633068e683caf2b5382f8d4 | from sympy import (
Abs, And, binomial, Catalan, combsimp, cos, Derivative, E, Eq, exp, EulerGamma,
factorial, Function, harmonic, I, Integral, KroneckerDelta, log,
nan, oo, pi, Piecewise, Product, product, Rational, S, simplify, Identity,
sin, sqrt, Sum, summation, Symbol, symbols, sympify, zeta, gamma... |
c2b6f593d045e4fd2c2f76dbd53195a43e3443e55eb02047f85123f1e7e21b12 | 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,... |
d0830604cf262431c77551037125e41cb86b1bf63c18888c99c8f24c3cb89257 | from sympy import (
Abs, acos, Add, asin, atan, Basic, binomial, besselsimp,
cos, cosh, count_ops, csch, diff, E,
Eq, erf, exp, exp_polar, expand, expand_multinomial, factor,
factorial, Float, Function, gamma, GoldenRatio, hyper,
hypersimp, I, Integral, integrate, KroneckerDelta, log, logcombine, Lt... |
ab50bb896a6f743ca611464dcb326f64bb0bb60c12918b428b1304f9f632203c | """
Module to implement predicate classes.
Class of every predicate registered to ``Q`` is defined here.
"""
|
75961a67c02ebc9ea812d3e18609bf8723affca1632c9dc2f5f6d561a7297fa1 | from sympy.assumptions import Predicate
from sympy.multipledispatch import Dispatcher
class FinitePredicate(Predicate):
"""
Finite predicate.
Explanation
===========
``Q.finite(x)`` is true if ``x`` is neither an infinity
nor a ``NaN``. In other words, ``ask(Q.finite(x))`` is true for all ``x... |
35037fb93b4cff43064c6c5860568bb9298761cd038655d8521fc8e3a96bd7a2 | from sympy.assumptions import Predicate
from sympy.multipledispatch import Dispatcher
class IntegerPredicate(Predicate):
"""
Integer predicate.
Explanation
===========
``Q.integer(x)`` is true iff ``x`` belongs to the set of integer
numbers.
Examples
========
>>> from sympy imp... |
0dc3385a77767ac27faa4b2bbef491e1b5c36a5c9dc01f61f192bf643ef19978 | """
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,
AskCommutativeHandler, TautologicalHandler, test_closed_group)
__all__ = [
'As... |
b35255e7ba36d05d6898a313f078bc16feb18fa4141ecc6c46232a48453d25ce | """
This module contains query handlers responsible for calculus queries:
infinitesimal, finite, etc.
"""
from sympy.assumptions import Q, ask
from sympy.core import Add, Mul, Pow, Symbol
from sympy.core.numbers import (Exp1, GoldenRatio, ImaginaryUnit, Infinity, NaN,
NegativeInfinity, Number, Pi, TribonacciConsta... |
92aec40e10947eb8bbeb1d587ce8a0a6363f1556e812d42cbf544f93e7649bfb | """
This module defines base class for handlers and some core handlers:
``Q.commutative`` and ``Q.is_true``.
"""
from sympy.assumptions import Q, ask
from sympy.core.logic import _fuzzy_group
from sympy.logic.boolalg import conjuncts
class AskHandler:
"""Base class that all Ask Handlers must inherit."""
pass... |
5ad18b3050afd4e8a9e7395f2821de73938cc8f016a1fdcd6c4097bffef31e64 | """
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 CommonHandler, test_closed_group
from sympy.matrices.expressions import MatMul, MatrixEx... |
9bd0271e046b3dc1071f2a526d38fd9e8456f42737a0d11b61e5ca894454148b | """
Predicates 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, NegativeInfi... |
8ec7cc33c2407cdd9a9c5684fc743854d5e94ac14e8d09440f371f394aa69dc2 | 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 global_assumptions, Predicate
from sympy.assumptions.ask import compute_known_facts, single_fact_lookup
from sympy.assumptions.hand... |
f05fc76fe940bb84e61bc4bdad4490971e2bfd04b1f73ba4633a7b902f66a4a3 | 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... |
8f88ef93ec283947ee18378f551ab308cd4cf51a391269e83fc50950b3cae864 | """ 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... |
235a77ba3de4150bf6d1c6ec677e0ae6b342c75fe90d2ec9c0750216cb69060b | from .diophantine import diophantine, classify_diop, diop_solve
__all__ = [
'diophantine', 'classify_diop', 'diop_solve'
]
|
2904ef49168e9520e93e251c1b2084273e96e1c04c003439559af151d18d2de6 | from sympy.core.add import Add
from sympy.core.assumptions import check_assumptions
from sympy.core.containers import Tuple
from sympy.core.compatibility import as_int, is_sequence, ordered
from sympy.core.exprtools import factor_terms
from sympy.core.function import _mexpand
from sympy.core.mul import Mul
from sympy.c... |
2788f3fb79631dd7df079d46bbd5808cd4f1589a5a7572db97083918263f8e17 | r"""
This module contains :py:meth:`~sympy.solvers.ode.dsolve` and different helper
functions that it uses.
:py:meth:`~sympy.solvers.ode.dsolve` solves ordinary differential equations.
See the docstring on the various functions for their uses. Note that partial
differential equations support is in ``pde.py``. Note t... |
d05bce0e7d54c662a941f4a53bc4fe63e2dadb765e85046bdcdbdc9061bc651e | #
# This is the module for ODE solver classes for single ODEs.
#
import typing
if typing.TYPE_CHECKING:
from typing import ClassVar
from typing import Dict, Type
from typing import Iterator, List, Optional
from sympy.core import S
from sympy.core.exprtools import factor_terms
from sympy.core.expr import Expr
fr... |
e24f752e2fa919f9d88d108ec4560ed5781a39c4e484639d46334954d41f0f42 | from sympy.core.containers import Tuple
from sympy.core.function import (Function, Lambda, nfloat, diff)
from sympy.core.mod import Mod
from sympy.core.numbers import (E, I, Rational, oo, pi)
from sympy.core.relational import (Eq, Gt,
Ne)
from sympy.core.singleton import S
from sympy.core.symbol import (Dummy, Symb... |
7e8b6a0a51ff543fc229c080feded47d635bf7ab2df70ab3fd9d3f356fae6d51 | from sympy import (Add, Matrix, Mul, S, symbols, Eq, pi, factorint, oo,
powsimp, Rational)
from sympy.core.function import _mexpand
from sympy.core.compatibility import ordered
from sympy.functions.elementary.trigonometric import sin
from sympy.solvers.diophantine import diophantine
from sympy.solver... |
0f9a17cd02a043747378bddb656867e0e99cbde137d2fbe5f6ebc0e28ee2574d | from sympy import (acos, acosh, atan, cos, Derivative, diff,
Dummy, Eq, Ne, exp, Function, I, Integral, LambertW, log, O, pi,
Rational, rootof, S, sin, sqrt, Subs, Symbol, tan, asin, sinh,
Piecewise, symbols, Poly, sec, re, im, atan2, collect)
from sympy.solvers.ode import (classify_ode,
homogeneous_or... |
d6b808c0404fc2102136dafbb7bceaef9c1f31ad53d464fc3ef8f86c7c427c14 | #
# The main tests for the code in single.py are currently located in
# sympy/solvers/tests/test_ode.py
#
r"""
This File contains test functions for the individual hints used for solving ODEs.
Examples of each solver will be returned by _get_examples_ode_sol_name_of_solver.
Examples should have a key 'XFAIL' which st... |
88725fe12cf51ba913acccdce8d27f1dc07fbc5e2288a89b78577b5e2b51912c | from sympy import (symbols, Symbol, diff, Function, Derivative, Matrix, Rational, S,
I, Eq, sqrt, Mul, pi)
from sympy.core.containers import Tuple
from sympy.functions import exp, cos, sin, log, tan, Ci, Si, erf, erfi
from sympy.matrices import dotprodsimp, NonSquareMatrixError
from sympy.solvers.ode... |
fe96dbd0bf57327d98aee37cba96f9bef2712bd60f32ae28bccea0ee4bb2d368 | from sympy import symbols, cos, sin, S, Eq, Equality, sqrt, Ne
from sympy.external import import_module
from sympy.testing.pytest import skip
from sympy.utilities.matchpy_connector import WildDot, WildPlus, WildStar, Replacer
matchpy = import_module("matchpy")
x, y, z = symbols("x y z")
def _get_first_match(expr, p... |
b02442e81092868d5ef67e1c9647b74171f1e1adea60baeef9b75d4bfb049850 | """Tests for simple tools for timing functions' execution. """
from sympy.utilities.timeutils import timed
def test_timed():
result = timed(lambda: 1 + 1, limit=100000)
assert result[0] == 100000 and result[3] == "ns", str(result)
result = timed("1 + 1", limit=100000)
assert result[0] == 100000 and r... |
cd1b6c908113b0d85a6de58e373cc47e41fff22c1cf94687ca29384e03cbae6c | 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... |
2550a841dc6896225e5778b9045a5f976ee462b59d64a7f91858e9d5e95ab837 | from typing import Any, Dict
from sympy.testing.pytest import raises
from sympy import (symbols, sympify, Function, Integer, Matrix, Abs,
Rational, Float, S, WildFunction, ImmutableDenseMatrix, sin, true, false, ones,
sqrt, root, AlgebraicNumber, Symbol, Dummy, Wild, MatrixSymbol, Q)
from sympy.combinatorics i... |
acf3409dde5bcd02d9dfbcb111af0517dd9469a7b373dcb521c1013a9026a2c6 | 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... |
d2685abf555cc0973844dea15518303a5e8767e6a7a9d2ddaf21ba952d71e046 | from sympy import diff, Integral, Limit, sin, Symbol, Integer, Rational, cos, \
tan, asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh, E, I, oo, \
pi, GoldenRatio, EulerGamma, Sum, Eq, Ne, Ge, Lt, Float, Matrix, Basic, \
S, MatrixSymbol, Function, Derivative, log, true, false, Range, Min, Max, \
... |
a36a28e5fd19e2692d6a7cd4af697894b8db4f5d0d5c671cc556aaf328de81a4 | from sympy.core import (pi, symbols, Rational, Integer, GoldenRatio, EulerGamma,
Catalan, Lambda, Dummy, Eq, Ne, Le, Lt, Gt, Ge)
from sympy.functions import Piecewise, sin, cos, Abs, exp, ceiling, sqrt
from sympy.testing.pytest import raises
from sympy.printing.glsl import GLSLPrinter
from sympy... |
72c63d87d82e942e8efee7a05e156ff74af07cc996527e8f416afa73d4fd1cca | # -*- 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, ... |
05ebd6d444310eb5ab4a921a04521bffbbcb7ed6b86975e8d2ec8bdb188419df | """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,... |
04bb4f0833c303d09a03c7d6885951c2cc3f8a40b27bde5d40956349c8196955 | from sympy import (Lambda, Symbol, Function, Derivative, Subs, sqrt,
log, exp, Rational, Float, sin, cos, acos, diff, I, re, im,
E, expand, pi, O, Sum, S, polygamma, loggamma, expint,
Tuple, Dummy, Eq, Expr, symbols, nfloat, Piecewise, Indexed,
Matrix, Basic, Dict, oo, zoo, nan, Pow)
fro... |
bc247026ea4a19a44b9e74e6b75fae88c9be4bc7aafedf955c54e074d5754363 | from sympy import (log, sqrt, Rational as R, Symbol, I, exp, pi, S,
cos, sin, Mul, Pow, O)
from sympy.simplify.radsimp import expand_numer
from sympy.core.function import expand, expand_multinomial, expand_power_base
from sympy.testing.pytest import raises
from sympy.testing.randtest import verify_numerically
fro... |
7e92373f3f171a2721e1f513b9a129ede1769aba5c36020b76e72e98e5f40e70 | from sympy.core.add import Add
from sympy.core.kind import NumberKind, UndefinedKind
from sympy.core.mul import Mul
from sympy.core.numbers import pi, zoo, I, AlgebraicNumber
from sympy.core.singleton import S
from sympy.core.symbol import Symbol
from sympy.integrals.integrals import Integral
from sympy.matrices import... |
61a0e823bd5a76f43cde7d13ca20f99b37813e00a9402b912c6c5ec93d933e0c | from sympy import (Basic, Symbol, sin, cos, atan, exp, sqrt, Rational,
Float, re, pi, sympify, Add, Mul, Pow, Mod, I, log, S, Max, symbols,
oo, zoo, Integer, sign, im, nan, Dummy, factorial, comp, floor, Poly,
FiniteSet
)
from sympy.core.parameters import distribute
from sympy.core.expr import u... |
c20c3fc8ac02e601d85b144711b54378738a4327059191f4671855112d00474e | """Implementation of :class:`CompositeDomain` class. """
from sympy.polys.domains.domain import Domain
from sympy.polys.polyerrors import GeneratorsError
from sympy.utilities import public
@public
class CompositeDomain(Domain):
"""Base class for composite domains, e.g. ZZ[x], ZZ(X). """
is_Composite = True... |
a7ae94d97e7c69c4872c7c4e4d4e9a259d1499d72ed6a8862140ed57c889083d | """Implementation of :class:`Ring` class. """
from sympy.polys.domains.domain import Domain
from sympy.polys.polyerrors import ExactQuotientFailed, NotInvertible, NotReversible
from sympy.utilities import public
@public
class Ring(Domain):
"""Represents a ring domain. """
is_Ring = True
def get_ring(s... |
a0ab40cedff5fa6e05fc079ef9f067ca99aadc1dfbb22a962b0e16a086a42b55 | """Trait for implementing domain elements. """
from sympy.utilities import public
@public
class DomainElement:
"""
Represents an element of a domain.
Mix in this trait into a class whose instances should be recognized as
elements of a domain. Method ``parent()`` gives that domain.
"""
def p... |
b723a312a00168e5d791a0442f4a8bab21b88392ad9ddefcd81ffac5309f89af | """Implementation of :class:`Field` class. """
from sympy.polys.domains.ring import Ring
from sympy.polys.polyerrors import NotReversible, DomainError
from sympy.utilities import public
@public
class Field(Ring):
"""Represents a field domain. """
is_Field = True
is_PID = True
def get_ring(self):
... |
4d16a50f6a5c150ddb88f1b2d631bc0a846c65a82af4846fece5bdb602e040ae | """Implementation of :class:`PolynomialRing` class. """
from sympy.core.compatibility import iterable
from sympy.polys.agca.modules import FreeModulePolyRing
from sympy.polys.domains.characteristiczero import CharacteristicZero
from sympy.polys.domains.compositedomain import CompositeDomain
from sympy.polys.domains.o... |
29730d4c3826c8a25aef76ffb0384c5f3a89d92c2f5a366561571b345a14985a | """Implementation of :class:`PolynomialRing` class. """
from sympy.polys.domains.ring import Ring
from sympy.polys.domains.compositedomain import CompositeDomain
from sympy.polys.polyerrors import CoercionFailed, GeneratorsError
from sympy.utilities import public
@public
class PolynomialRing(Ring, CompositeDomain):... |
51d351bbaa2076a811cf3118782ba42ad9ff9c2c85baa931efde6232642015db | """Implementation of :class:`Domain` class. """
from typing import Any, Optional, Type
from sympy.core import Basic, sympify
from sympy.core.compatibility import HAS_GMPY, is_sequence, ordered
from sympy.core.decorators import deprecated
from sympy.polys.domains.domainelement import DomainElement
from sympy.polys.or... |
5513c85d60e4c484ed5a783c55e03c98e32b8823f89f7dd2e42067bb63b4b2bb | """Tests for user-friendly public interface to polynomial functions. """
import pickle
from sympy.polys.polytools import (
Poly, PurePoly, poly,
parallel_poly_from_expr,
degree, degree_list,
total_degree,
LC, LM, LT,
pdiv, prem, pquo, pexquo,
div, rem, quo, exquo,
half_gcdex, gcdex, in... |
8eec704896f7350f1be66ad3663e82f5a099a5f1c5472c2151e232e1a6180f26 | """Finite extensions of ring domains."""
from sympy.polys.domains.domain import Domain
from sympy.polys.domains.domainelement import DomainElement
from sympy.polys.polyerrors import (CoercionFailed, NotInvertible,
GeneratorsError)
from sympy.polys.polytools import Poly
from sympy.printing.defaults import Defau... |
d9f5cfb543905043dc7abee9cfd4ec0ce99b16596d622734fd1f1653062b4732 | """
sympy.polys.matrices package.
The main export from this package is the DomainMatrix class which is a
lower-level implementation of matrices based on the polys Domains. This
implementation is typically a lot faster than sympy's standard Matrix class
but is a work in progress and is still experimental.
"""
from .d... |
113edcca179aed9cfe5796ac6ac77896e7915f3d8c5dbd265da5e8f582edfd3f | """
Module for the DomainMatrix class.
A DomainMatrix represents a matrix with elements that are in a particular
Domain. Each DomainMatrix internally wraps a DDM which is used for the
lower-level operations. The idea is that the DomainMatrix class provides the
convenience routines for converting between Expr and the ... |
aad701d51b58e7421e3d1bd92c1177fdf36918ad72741fdeb3cc37a841ce55f6 | """
Module to define exceptions to be used in sympy.polys.matrices modules and
classes.
Ideally all exceptions raised in these modules would be defined and documented
here and not e.g. imported from matrices. Also ideally generic exceptions like
ValueError/TypeError would not be raised anywhere.
"""
from sympy.matr... |
60c127a946fffca8d249ee82ee6e0005c710ba4c4fd0e5f831ed920169efc4a7 | """
Module for the ddm_* routines for operating on a matrix in list of lists
matrix representation.
These routines are used internally by the DDM class which also provides a
friendlier interface for them. The idea here is to implement core matrix
routines in a way that can be applied to any simple list representation... |
e263b75c4f04df9a0c6e9278da9747b37ea1f220350d92975c0b44df30b709b4 | """
Routines for computing eigenvectors with DomainMatrix.
"""
from sympy.core.symbol import Dummy
from ..agca.extensions import FiniteExtension
from ..factortools import dup_factor_list
from ..polyroots import roots
from ..polytools import Poly
from ..rootoftools import CRootOf
from .domainmatrix import DomainMatr... |
1ebae9a3ad80aa8a8b82a088386cfaf54296aeab2208695c4d9277f261a1bdcf | """
Module for the DDM class.
The DDM class is an internal representation used by DomainMatrix. The letters
DDM stand for Dense Domain Matrix. A DDM instance represents a matrix using
elements from a polynomial Domain (e.g. ZZ, QQ, ...) in a dense-matrix
representation.
Basic usage:
>>> from sympy import ZZ, QQ... |
35b0dcb62ed4cfaa6b7bdfcd09a3bfb3ff58b455f46072d94d49a6a8108fc2d9 | """Tests for classes defining properties of ground domains, e.g. ZZ, QQ, ZZ[x] ... """
from sympy import I, S, sqrt, sin, oo, Poly, Float, Rational, pi
from sympy.abc import x, y, z
from sympy.core.compatibility import HAS_GMPY
from sympy.polys.domains import (ZZ, QQ, RR, CC, FF, GF, EX, ZZ_gmpy,
ZZ_python, QQ_g... |
56f4d761f7326aa59d6ffec89a1db26b672214cedd9aecb6d49765498132aa83 | from sympy import symbols, sin, cos
from sympy.polys import QQ, ZZ
from sympy.polys.polytools import Poly
from sympy.polys.polyerrors import NotInvertible
from sympy.polys.agca.extensions import FiniteExtension
from sympy.polys.domainmatrix import DomainMatrix
from sympy.testing.pytest import raises
from sympy.abc im... |
1f5a71177a47fd9b1fdd1f7b9e4780b9b7f0fb3523219b853b685543a11b8cfe | from sympy.testing.pytest import raises
from sympy.core.compatibility import HAS_GMPY
from sympy.polys import ZZ, QQ
from sympy.polys.matrices.ddm import DDM
from sympy.polys.matrices.exceptions import (
DDMShapeError, NonInvertibleMatrixError, DDMDomainError,
DDMBadInputError)
def test_DDM_init():
... |
1d74278c054ca7f48a107a1b08ed0249e974229271879dde0da9c5d3b2cf1ff9 | from sympy.testing.pytest import raises
from sympy.core.numbers import Rational
from sympy.functions import sqrt
from sympy.matrices.common import (NonInvertibleMatrixError,
NonSquareMatrixError, ShapeError)
from sympy.matrices.dense import Matrix
from sympy.polys import ZZ, QQ
from sympy.polys.matrices.domainma... |
e03c1f81ebcab653ad5424fad951e7981e0a8629fa4d26de91058e868fcaa3df | from sympy.testing.pytest import raises
from sympy.polys import ZZ, QQ
from sympy.polys.matrices.ddm import DDM
from sympy.polys.matrices.dense import (
ddm_iadd, ddm_isub, ddm_ineg, ddm_imatmul, ddm_imul, ddm_irref,
ddm_idet, ddm_iinv, ddm_ilu, ddm_ilu_split, ddm_ilu_solve, ddm_berk)
from sympy.polys... |
cd2ae46a351a34abf6df460d8786417ac4fc1692288c8fa9334064ab27cdfb21 | from sympy.core.backend import (S, sympify, expand, sqrt, Add, zeros,
ImmutableMatrix as Matrix)
from sympy import trigsimp
from sympy.printing.defaults import Printable
from sympy.utilities.misc import filldedent
from sympy.core.evalf import EvalfMixin, prec_to_dps
__all__ = ['Vector']
class Vector(Printable, E... |
dfe2fbe4608a7bf3c33fee60ca767716694b7f6db5fb4b9a4b6aaab6613c358d | from sympy.core.backend import sympify, Add, ImmutableMatrix as Matrix
from sympy.core.evalf import EvalfMixin, prec_to_dps
from sympy.printing.defaults import Printable
__all__ = ['Dyadic']
class Dyadic(Printable, EvalfMixin):
"""A Dyadic object.
See:
https://en.wikipedia.org/wiki/Dyadic_tensor
Kan... |
bad6f960bcb1a72fbef40272666db071f5bbf3dca549020efaa86f9b9cde3d0c | """
This module can be used to solve 2D beam bending problems with
singularity functions in mechanics.
"""
from sympy.core import S, Symbol, diff, symbols
from sympy.solvers import linsolve
from sympy.printing import sstr
from sympy.functions import SingularityFunction, Piecewise, factorial
from sympy.core import symp... |
0f4ce3290dd0054a44d7af0b1cc9ce7c5c20147a708c48dc06beb31f17e7c0c1 | 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 ... |
f24ac10375f92c22f161c525c37d282282f710069cbacaab0b84e1f6256a9504 | 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 =... |
e48722bbc5b1af81dd6f64d3d7c3991e1b33ee8ac09106d775e83db1a2f32c90 | from sympy import expand, Symbol, symbols, S, Interval, pi, Rational, simplify
from sympy.physics.continuum_mechanics.beam import Beam
from sympy.functions import SingularityFunction, Piecewise, meijerg, Abs, log
from sympy.testing.pytest import raises
from sympy.physics.units import meter, newton, kilo, giga, milli
fr... |
cd0c663ff6069daf4b8516fee129d7bc7ed2749808dd2735b1fc22a71109ed87 | import functools, itertools
from sympy.core.sympify import sympify
from sympy.core.expr import Expr
from sympy.core import Basic
from sympy.tensor.array import ImmutableDenseNDimArray
from sympy import Symbol
from sympy.core.numbers import Integer
class ArrayComprehension(Basic):
"""
Generate a list comprehen... |
20587f4da68ad2c95fe50a1cea26aa0fcdfa5abfdfe1a7388566506dbca5da6d | r"""
N-dim array module for SymPy.
Four classes are provided to handle N-dim arrays, given by the combinations
dense/sparse (i.e. whether to store all elements or only the non-zero ones in
memory) and mutable/immutable (immutable classes are SymPy objects, but cannot
change after they have been created).
Examples
===... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.