hash stringlengths 64 64 | content stringlengths 0 1.51M |
|---|---|
8b6136ca6329373c45a8b722017360ca7725c996449852dff05b05be37736d5c | 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... |
47010335bfc8ac34dfeca1123244917955624f68973deff3244951c50c4ded01 | from sympy import symbols, sin, Matrix, Interval, Piecewise, Sum, lambdify, \
Expr, sqrt
from sympy.testing.pytest import raises
from sympy.printing.tensorflow import TensorflowPrinter
from sympy.printing.lambdarepr import lambdarepr, LambdaPrinter, NumExprPrinter
x, y, z = symbols("x,y,z")
i, a, b... |
5a840740247935d1d23b909e129d6194ab70a7ec91dda7fc1590578789ead7e5 | 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, \
... |
800a83128b0d1468bbcea4ba1886c5f711a1d5bdd6ebd91be1c03d9325433674 | """
Important note on tests in this module - the Theano printing functions use a
global cache by default, which means that tests using it will modify global
state and thus not be independent from each other. Instead of using the "cache"
keyword argument each time, this module uses the theano_code_ and
theano_function_ ... |
5ced500f3a711cc0e691266e7b2dea06b0a3714880eeef9650046c1098cf8382 | from sympy.core import (S, pi, oo, symbols, Function, Rational, Integer,
Tuple, Symbol, EulerGamma, GoldenRatio, Catalan,
Lambda, Mul, Pow, Mod, Eq, Ne, Le, Lt, Gt, Ge)
from sympy.codegen.matrix_nodes import MatrixSolve
from sympy.functions import (arg, atan2, bernoulli, ... |
9b0be096895974c34309a1b19a666bbbe735fa8a3f5d68ad8cf1662062d67ed6 | 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, warns_deprecated_sympy
from sympy.printing.glsl impor... |
d839e6a297d7cf9ba3fe1083dcb4e615e41d2d70cf1d927789f8074d6ea103e2 | from sympy import Rational, sqrt, symbols, sin, exp, log, sinh, cosh, cos, pi, \
I, erf, tan, asin, asinh, acos, atan, Function, Derivative, diff, simplify, \
LambertW, Ne, Piecewise, Symbol, Add, ratsimp, Integral, Sum, \
besselj, besselk, bessely, jn, tanh
from sympy.integrals.heurisch import components, ... |
f4762d3811798439ebdc4cabdaa8042e18af25e6ce53304cd1a05672d928e7b4 | from sympy import (
Abs, acos, acosh, Add, And, asin, asinh, atan, Ci, cos, sinh, cosh,
tanh, Derivative, diff, DiracDelta, E, Ei, Eq, exp, erf, erfc, erfi,
EulerGamma, Expr, factor, Function, gamma, gammasimp, I, Idx, im, IndexedBase,
integrate, Interval, Lambda, LambertW, log, Matrix, Max, meijerg, Mi... |
7abd87ae7e485b87667e51d551d9c35b6c930e45bc84dd00ac552880a914d5eb | from sympy.integrals.transforms import (mellin_transform,
inverse_mellin_transform, laplace_transform, inverse_laplace_transform,
fourier_transform, inverse_fourier_transform,
sine_transform, inverse_sine_transform,
cosine_transform, inverse_cosine_transform,
hankel_transform, inverse_hankel_transfo... |
1a1099a2155d0dd458e83054a7fe6d0d2aa07a84ff8bccfdff5d149c02353bc6 | """Most of these tests come from the examples in Bronstein's book."""
from sympy.integrals.risch import DifferentialExtension, derivation
from sympy.integrals.prde import (prde_normal_denom, prde_special_denom,
prde_linear_constraints, constant_system, prde_spde, prde_no_cancel_b_large,
prde_no_cancel_b_small, ... |
0c0801bf2f88f9723dc3d16f15e5d3bca96c0ab350462f8edf64d4cfd0544501 | from sympy import (Add, Basic, Expr, S, Symbol, Wild, Float, Integer, Rational, I,
sin, cos, tan, exp, log, nan, oo, sqrt, symbols, Integral, sympify,
WildFunction, Poly, Function, Derivative, Number, pi, NumberSymbol, zoo,
Piecewise, Mul, Pow, nsimplify, ratsimp... |
b044515a9f12f6482546295debc8564974df982f638626219964253b64cee267 | """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,... |
2866e9f751222cf966f9d8f9eb2232323788022a70673e54d138fd19a0a8e762 | """Tests for tools for manipulating of large commutative expressions. """
from sympy import (S, Add, sin, Mul, Symbol, oo, Integral, sqrt, Tuple, I,
Function, Interval, O, symbols, simplify, collect, Sum,
Basic, Dict, root, exp, cos, Dummy, log, Rational)
from sympy.core.exprtools... |
7828598c4db9c9be8ca0552083c2a5192bf4dba3536c57ad506a802d9f99ee08 | from sympy.core import (
Basic, Rational, Symbol, S, Float, Integer, Mul, Number, Pow,
Expr, I, nan, pi, symbols, oo, zoo, N)
from sympy.core.parameters import global_parameters
from sympy.core.tests.test_evalf import NS
from sympy.core.function import expand_multinomial
from sympy.functions.elementary.miscella... |
c409fc88aa0c2ae8ab3327c8cdc7ace3127cd44d78075eefdfccd7f4eb3b6848 | from sympy import I, sqrt, log, exp, sin, asin, factorial, Mod, pi, oo
from sympy.core import Symbol, S, Rational, Integer, Dummy, Wild, Pow
from sympy.core.assumptions import (assumptions, check_assumptions,
failing_assumptions, common_assumptions)
from sympy.core.facts import InconsistentAssumptions
from sympy im... |
4d1e8e77444eb986eff82ff8f56c46b8eb5caa3560bb4008a4fad6854a8afd12 | from sympy import (Symbol, exp, Integer, Float, sin, cos, log, Poly, Lambda,
Function, I, S, sqrt, srepr, Rational, Tuple, Matrix, Interval, Add, Mul,
Pow, Or, true, false, Abs, pi, Range, Xor)
from sympy.abc import x, y
from sympy.core.sympify import (sympify, _sympify, SympifyError, kernS,
CantSympify)
fr... |
5d2a714eda63b96b401919e42d35d870cb4b11dd741f75697060b157df6a282f | 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... |
912b57480b6ad5be53937beb1337bbfc4f14327f1b17dd46a21ee157386d6b1d | """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):... |
a4a47775f38e5ea048c1fde3bd19daaa003eb7561859db9b0aecf7c8d9f17a95 | """Implementation of :class:`FractionField` class. """
from sympy.polys.domains.compositedomain import CompositeDomain
from sympy.polys.domains.field import Field
from sympy.polys.polyerrors import CoercionFailed, GeneratorsError
from sympy.utilities import public
@public
class FractionField(Field, CompositeDomain):... |
3636566700dec1a8f86776a046380fca2b7a0a5a23cf72de4d439edf690053f2 | """Implementation of :class:`ExpressionDomain` class. """
from sympy.core import sympify, SympifyError
from sympy.polys.domains.characteristiczero import CharacteristicZero
from sympy.polys.domains.field import Field
from sympy.polys.domains.simpledomain import SimpleDomain
from sympy.polys.polyutils import Picklable... |
eaa55be19cdfabc02bc43ca0857c16e55bf0e126adb5d22dd07531e167270fc5 | """Implementation of :class:`FractionField` class. """
from sympy.polys.domains.field import Field
from sympy.polys.domains.compositedomain import CompositeDomain
from sympy.polys.domains.characteristiczero import CharacteristicZero
from sympy.polys.polyclasses import DMF
from sympy.polys.polyerrors import Generators... |
ec7a3ab7821c4384ab51e752b0947e07879b0d7237f01a7ce9b66a9d115d4f7b | """Domains of Gaussian type."""
from sympy.core.numbers import I
from sympy.polys.polyerrors import CoercionFailed
from sympy.polys.domains.integerring import ZZ
from sympy.polys.domains.rationalfield import QQ
from sympy.polys.domains.algebraicfield import AlgebraicField
from sympy.polys.domains.domain import Domain
... |
273257e0edc451052c470117bc6ce97dd1371882130e21daa5ea601fb761d57d | """Test sparse polynomials. """
from functools import reduce
from operator import add, mul
from sympy.polys.rings import ring, xring, sring, PolyRing, PolyElement
from sympy.polys.fields import field, FracField
from sympy.polys.domains import ZZ, QQ, RR, FF, EX
from sympy.polys.orderings import lex, grlex
from sympy.... |
8366120600623f84e454f2b0ed48fbc7cb2569bdbd2f528541206c7ef836a03c | """Tests for tools for constructing domains for expressions. """
from sympy.polys.constructor import construct_domain
from sympy.polys.domains import ZZ, QQ, ZZ_I, QQ_I, RR, CC, EX
from sympy.polys.domains.realfield import RealField
from sympy.polys.domains.complexfield import ComplexField
from sympy import (
S, ... |
098e01dc397100bedad14e6baca858a231838fb9627bfdd3f9fdcbbed9063927 | """Tests for computational algebraic number field theory. """
from sympy import (S, Rational, Symbol, Poly, sqrt, I, oo, Tuple, expand,
pi, cos, sin, tan, exp, GoldenRatio, TribonacciConstant, cbrt)
from sympy.solvers.solveset import nonlinsolve
from sympy.geometry import Circle, intersection
from sympy.testing.py... |
76d2f40cfee3ea71ba0f34dc340b956b2b351c95effbccc5becf45d9f22b0d08 | """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... |
cb032f330153ac292600ae5077148930e813359c10811a6513d133f7fa5249d2 | """Tests for OO layer of several polynomial representations. """
from sympy.polys.domains import ZZ, QQ
from sympy.polys.polyclasses import DMP, DMF, ANP
from sympy.polys.polyerrors import ExactQuotientFailed, NotInvertible
from sympy.polys.specialpolys import f_polys
from sympy.testing.pytest import raises
f_0, f_1,... |
c9d3bff9449d415a4be37beca34b73367f19d6f54943fb1ec3b94fb0b377d811 | from sympy.testing.pytest import raises
from sympy.polys.polymatrix import PolyMatrix
from sympy.polys import Poly
from sympy import S, QQ, ZZ, Matrix
from sympy.abc import x, y
def _test_polymatrix():
pm1 = PolyMatrix([[Poly(x**2, x), Poly(-x, x)], [Poly(x**3, x), Poly(-1 + x, x)]])
v1 = PolyMatrix([[1, 0... |
ced39e98ede4b0ddaa8e2d17e54aa64e96151ca32f02c117d4c7c2a8df889dbd | '''Functions returning normal forms of matrices'''
from .domainmatrix import DomainMatrix
def smith_normal_form(m):
'''
Return the Smith Normal Form of a matrix `m` over the ring `domain`.
This will only work if the ring is a principal ideal domain.
Examples
========
>>> from sympy import Z... |
4bc01c3dc9645628a0a2344965e10e11c4c44d82efe9f2cccbe3ac9132afdecb | """
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 ... |
49260bd89d6188f0ec53a2bbf6aad5ba8343adb413c69e74ea9e8978f6856560 | #
# sympy.polys.matrices.linsolve module
#
# This module defines the _linsolve function which is the internal workhorse
# used by linsolve. This computes the solution of a system of linear equations
# using the SDM sparse matrix implementation in sympy.polys.matrices.sdm. This
# is a replacement for solve_lin_sys in sy... |
8c8857c33f9d2def141463457b13a48960eddf77b5168ef14ba19ddeddc5cdc7 | """
Module for the SDM class.
"""
from operator import add, neg, pos, sub
from collections import defaultdict
from .exceptions import DDMBadInputError, DDMDomainError, DDMShapeError
from .ddm import DDM
class SDM(dict):
r"""Sparse matrix based on polys domain elements
This is a dict subclass and is a wr... |
ce8b0e41f2de2ac32902fd6c9be2473e778698c4de10bbc096837128c919f14a | """
Module for the DomainScalar class.
A DomainScalar represents an element which is in a particular
Domain. The idea is that the DomainScalar class provides the
convenience routines for unifying elements with different domains.
It assists in Scalar Multiplication and getitem for DomainMatrix.
"""
from ..constructo... |
154700b180ccddcc63d694bbea0fd7d92ceff602f967998557cb752e0928c91f | """
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... |
e3bc0db26ab342a5ca1b9ca8ef147bc3c1991f2fafa82597a9cf96e3a0e30985 | """
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... |
b977171f3a4e5705a6dd87e4e6b77e468d4298aaa26f3484849749ee5d05f48f | """Tests for classes defining properties of ground domains, e.g. ZZ, QQ, ZZ[x] ... """
from sympy import I, S, sqrt, sin, oo, Poly, Float, Integer, Rational, pi
from sympy.abc import x, y, z
from sympy.utilities.iterables import cartes
from sympy.core.compatibility import HAS_GMPY
from sympy.polys.domains import (ZZ... |
2c069f467f10cb66cc0569e50b6edfca261043b31f9828698d960cc4e3714c62 | from sympy.testing.pytest import raises
from sympy import Symbol, sympify
from sympy.polys.matrices.normalforms import invariant_factors, smith_normal_form
from sympy.polys.domains import ZZ, QQ
from sympy.polys.matrices import DomainMatrix
def test_smith_normal():
def DM(elems, domain):
conv = lambda e... |
d44311f61a1f01c90f033abbe9af374625f41ce818a73c9efd2b75f9c3737b1f | 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():
... |
f4740bf795e5c725c73437ff50137db7575affdb3244d64639bec82a49a39fe5 | from sympy.testing.pytest import raises
from sympy.core.symbol import S
from sympy.polys import ZZ, QQ
from sympy.polys.matrices.domainscalar import DomainScalar
from sympy.polys.matrices.domainmatrix import DomainMatrix
def test_DomainScalar___new__():
raises(TypeError, lambda: DomainScalar(ZZ(1), QQ))
rais... |
1096639da63ed3f1bb4e2cb6fc04fe256a32c27eaaf6397b19557cf0b40e1e6b | 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.domainm... |
713b44b35f6b1b98dcef845dbfff40d7a52e61a48ee359ad30ccae8dac3a1a27 | #
# test_linsolve.py
#
# Test the internal implementation of linsolve.
#
from sympy.testing.pytest import raises
from sympy import S, Eq, I
from sympy.abc import x, y, z
from sympy.polys.matrices.linsolve import _linsolve
from sympy.polys.solvers import PolyNonlinearError
def test__linsolve():
assert _linso... |
3f710408ba8ba713fbb98d434d1958985ba00bac5bff17cade32760cd8b0ef79 | 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_transpose,
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... |
ee43c5e1bf1b68d6c58936ddd4e1bbdf2b6e2386706b15de94dea1833cd60b7c | """
Tests for the basic functionality of the SDM class.
"""
from sympy.core.compatibility import HAS_GMPY
from sympy.testing.pytest import raises
from sympy import QQ, ZZ
from sympy.polys.matrices.sdm import SDM
from sympy.polys.matrices.ddm import DDM
from sympy.polys.matrices.exceptions import (DDMBadInputError, DD... |
80925dd76c779c242ab6d691bf59a74b00643bc20fdfb7d05c6f15201b2c31af | # -*- coding: utf-8 -*-
import sys
from sympy.assumptions import Q
from sympy.core import Symbol, Function, Float, Rational, Integer, I, Mul, Pow, Eq
from sympy.functions import exp, factorial, factorial2, sin
from sympy.logic import And
from sympy.series import Limit
from sympy.testing.pytest import raises, skip
f... |
0176c6c255f3dd9057a43f6b000c601a62c0b395feb0e8bba0434d77d8573990 | 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,... |
06f8128b28b830334810a6e2363286dbfea6852906817cf7547c26ddc957e4a9 | # 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... |
8b3fd96cc6648d222675867cb70d089ccbb9d1083dcb269f7df079da25413bf7 | """
Several methods to simplify expressions involving unit objects.
"""
from functools import reduce
from collections.abc import Iterable
from sympy import Add, Mul, Pow, Tuple, sympify
from sympy.core.compatibility import ordered
from sympy.matrices.common import NonInvertibleMatrixError
from sympy.physics.units.dime... |
2582a75468e8501fdf3ac4a25ac7740b2addd64165546958669b70149df40a32 | from sympy.core.backend import (diff, expand, sin, cos, sympify, eye, symbols,
ImmutableMatrix as Matrix, MatrixBase)
from sympy import (trigsimp, solve, Symbol, Dummy)
from sympy.physics.vector.vector import Vector, _check_vector
from sympy.utilities.misc import translate
from warnings... |
9a3f50a4d30dd0ae0647278d97a21756e763ad95c05380472675d281e5a07188 | from sympy import Pow, Tuple, pi, sstr, sympify, symbols
from sympy.physics.units import (
G, centimeter, coulomb, day, degree, gram, hbar, hour, inch, joule, kelvin,
kilogram, kilometer, length, meter, mile, minute, newton, planck,
planck_length, planck_mass, planck_temperature, planck_time, radians,
s... |
4d4c89bcc99e5537364c593f7e28c796bff233bd1b36a5c00659c1672d544353 | from sympy import (symbols, sin, cos, pi, zeros, eye, simplify, ImmutableMatrix
as Matrix)
from sympy.physics.vector import (ReferenceFrame, Vector, CoordinateSym,
dynamicsymbols, time_derivative, express,
dot)
from sympy.physics.vec... |
774ef2f8583c73b6ef5f77c18ad6343a24693c02cc848960086bc0aabcd6d963 | from sympy.assumptions.cnf import EncodedCNF
def minisat22_satisfiable(expr, all_models=False, minimal=False):
if not isinstance(expr, EncodedCNF):
exprs = EncodedCNF()
exprs.add_prop(expr)
expr = exprs
from pysat.solvers import Minisat22
# Return UNSAT when False (encoded as 0) ... |
1aa3a6f57437bbc4010f8d4c7d7ffb1582ecf56d41bb3a7312299e6316ffa00e | from sympy.assumptions.ask import Q
from sympy.assumptions.refine import refine
from sympy.core.numbers import oo
from sympy.core.relational import Equality, Eq, Ne
from sympy.core.singleton import S
from sympy.core.symbol import (Dummy, symbols)
from sympy.functions import Piecewise
from sympy.functions.elementary.mis... |
841d10a292a4cfc41ff28b3ef0621bed06dd8e866a901fb5e7ab7915e829b4da | """For more tests on satisfiability, see test_dimacs"""
from sympy import symbols, Q
from sympy.logic.boolalg import And, Implies, Equivalent, true, false
from sympy.logic.inference import literal_symbol, \
pl_true, satisfiable, valid, entails, PropKB
from sympy.logic.algorithms.dpll import dpll, dpll_satisfiable... |
6be8f363083e434f94e0be56811e3089dc2a88f49e2a28d09b4d7bd29c4ee1e1 | from sympy.assumptions import Q
from sympy.core.expr import Expr
from sympy.core.add import Add
from sympy.core.function import Function
from sympy.core.numbers import I, Integer, oo, pi, Rational
from sympy.core.singleton import S
from sympy.core.symbol import Symbol, symbols
from sympy.functions.elementary.complexes ... |
7247c60c283633a825baff571677d44606bc8317761d32fb697dbcd6ceb0cba7 | from sympy.combinatorics import Permutation
from sympy.core.symbol import symbols
from sympy.matrices import Matrix
from sympy.matrices.expressions import (
PermutationMatrix, BlockDiagMatrix, BlockMatrix)
def test_connected_components():
a, b, c, d, e, f, g, h, i, j, k, l, m = symbols('a:m')
M = Matrix(... |
e3ded36995b15fa83bb8e9ba8c2c1b2d1d0008ca3f909fd148b29bb61c83826d | import random
from sympy.core.numbers import I
from sympy import symbols, Symbol, Rational, sqrt, Poly
from sympy.matrices import Matrix, eye, ones
from sympy.abc import x, y, z
from sympy.testing.pytest import raises
from sympy.matrices.common import NonSquareMatrixError
from sympy.functions.combinatorial.factorials i... |
88bdf8e6704199b8ddc434d18133064633ee212c39efa4731f230aa08d05bd6a | from sympy import Rational, I, expand_mul, S, simplify, sqrt
from sympy.matrices.matrices import NonSquareMatrixError
from sympy.matrices import Matrix, zeros, eye, SparseMatrix
from sympy.abc import x, y, z
from sympy.testing.pytest import raises, slow
from sympy.testing.matrices import allclose
def test_LUdecomp():... |
6ccb5e95c09400f0bfc30d74660619a738eb6951e136470b3e87fedd0483daf6 | from sympy.testing.pytest import warns_deprecated_sympy
from sympy import Symbol, Poly
from sympy.matrices import Matrix
from sympy.matrices.normalforms import invariant_factors, smith_normal_form
from sympy.polys.domains import ZZ, QQ
def test_smith_normal():
m = Matrix([[12,6,4,8],[3,9,6,12],[2,16,14,28],[20,1... |
85815ae675ee15e4d8721fe821b3fa6d6b0a3f26afaaeb04a30f71967aa6b1c3 | import random
import concurrent.futures
from collections.abc import Hashable
from sympy import (
Abs, Add, E, Float, I, Integer, Max, Min, Poly, Pow, PurePoly, Rational,
S, Symbol, cos, exp, log, oo, pi, signsimp, simplify, sin,
sqrt, symbols, sympify, trigsimp, tan, sstr, diff, Function, expand, FiniteSet... |
98f2824c49994345f8553febd88c30bafcba5b7ba9982f04b9f44abe979ae2aa | from sympy import (S, Dummy, Lambda, symbols, Interval, Intersection, Set,
EmptySet, FiniteSet, Union, ComplexRegion, Mul)
from sympy.multipledispatch import dispatch
from sympy.sets.conditionset import ConditionSet
from sympy.sets.fancysets import (Integers, Naturals, Reals, Range,
ImageSet, Rat... |
b456eb903fab77041ce0b3d48128b1545e877d90f0a124c290be9ffc56d76251 | from sympy.core.expr import unchanged
from sympy.sets import (ConditionSet, Intersection, FiniteSet,
EmptySet, Union, Contains, ImageSet)
from sympy import (Symbol, Eq, Ne, S, Abs, sin, asin, pi, Interval,
And, Mod, oo, Function, Lambda, symbols, Matrix, MatrixSymbol)
from sympy.testing.pytest import raises, wa... |
9dfbbb4ab2cd600b6ff49c743555f7bf8c1173c7e67223c98871f604d625d75e | from sympy.core.expr import unchanged
from sympy.core.singleton import S
from sympy.core.symbol import Symbol
from sympy.sets.contains import Contains
from sympy.sets.fancysets import Interval
from sympy.sets.powerset import PowerSet
from sympy.sets.sets import FiniteSet
from sympy.testing.pytest import raises, XFAIL
... |
92bb1c064b3892c45bab31818649b0b74f3927a44382b7e0caa4af2542a47601 | from sympy import Symbol, Contains, S, Interval, FiniteSet, oo, Eq
from sympy.core.expr import unchanged
from sympy.testing.pytest import raises
def test_contains_basic():
raises(TypeError, lambda: Contains(S.Integers, 1))
assert Contains(2, S.Integers) is S.true
assert Contains(-2, S.Naturals) is S.false
... |
c66145f7df6ab8fb67dfe5d0395482ce5dc4ddc334e1a21bb0a2147e4845c691 | from sympy.sets.ordinals import Ordinal, OmegaPower, ord0, omega
from sympy.testing.pytest import raises
def test_string_ordinals():
assert str(omega) == 'w'
assert str(Ordinal(OmegaPower(5, 3), OmegaPower(3, 2))) == 'w**5*3 + w**3*2'
assert str(Ordinal(OmegaPower(5, 3), OmegaPower(0, 5))) == 'w**5*3 + 5'
... |
c9e295f505af0383b24aefd1bb7f6f1bdee7138d34bc3da4940493e8dbe194ce |
from sympy.core.expr import unchanged
from sympy.sets.fancysets import (ImageSet, Range, normalize_theta_set,
ComplexRegion)
from sympy.sets.sets import (Complement, FiniteSet, Interval, Union, imageset,
Intersection, ProductSet, Contains)
from sympy.simpl... |
6a2611c341bf5b6110729ba491cac05ca23859b6be2e40b02e89c337b15f972e | 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, ... |
c7fe7235ff8f370ef7e7b594456dd4e046dbab196c73c8ebc0ec8392b6b818c4 | """
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... |
df68be0bd1a6bb5ccb5ce84281db478c58e58e1803b39c469a577eb8b4c1da17 | from collections import defaultdict
from functools import reduce
from sympy.core import (sympify, Basic, S, Expr, expand_mul, factor_terms,
Mul, Dummy, igcd, FunctionClass, Add, symbols, Wild, expand)
from sympy.core.cache import cacheit
from sympy.core.compatibility import iterable, SYMPY_INTS
from sympy.core.fun... |
0f5415349ab1c496f544b4b6f8336c924535aa8e438ec21f2bdfb652b15d39a2 | """
This module contains functions to:
- solve a single equation for a single variable, in any domain either real or complex.
- solve a single transcendental equation for a single variable in any domain either real or complex.
(currently supports solving in real domain only)
- solve a system of lin... |
367ebca63092bed017eba4f229449513aefb62ad0e121c5def5ad1c326cda55e | from sympy import (
symbols, sin, simplify, cos, trigsimp, tan, exptrigsimp,sinh,
cosh, diff, cot, Subs, exp, tanh, S, integrate, I,Matrix,
Symbol, coth, pi, log, count_ops, sqrt, E, expand, Piecewise , Rational
)
from sympy.testing.pytest import XFAIL
from sympy.abc import x, y
def test_trigsimp1(... |
d37ee7eeb90293403084712889bcde2d579c6069ddbac0707f2f9a776c8e2a82 | 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... |
0a2aaa538fd94130c76242f69aa0b8ce8422ae65839343817fb8c48dbf4a5a73 | #
# 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 Add, S, Pow
from sympy.core.exprtools import factor_terms
from sympy.core.expr impor... |
daf095ab0d5396fc403ec262d8cc91a9ee3d5a67d77fdc739dbb9244562d9b3d | from sympy.core.containers import Tuple
from sympy.core.compatibility import ordered
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... |
4e2214240b3f99f1941e0e59572550a9b99f97f01e43fdd37e2894f1a2295ada | from sympy import (acosh, cos, Derivative, diff,
Eq, exp, Function, I, Integral, log, O, pi,
Rational, S, sin, sqrt, Subs, Symbol, tan,
symbols, Poly, re, im, atan2, collect)
from sympy.solvers.ode import (classify_ode,
homogeneous_order, dsolve)
from sympy.solvers.ode.subscheck import checkodesol
fro... |
e2bd9b0ac3054f75b3f03abd385928e29921b36741c8357222b55a3781b7968d | from sympy.core.backend import (S, sympify, expand, sqrt, Add, zeros, acos,
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(Printa... |
0f9f43805bda26eedc36f61a74d850413c5968ca64d3f6c244307a65cf0b12e8 | 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 ... |
22920a0673914a5fbca39f01e6b58e1650a529c3fc8deb265ede2dbb9eaccd23 | from sympy import (S, Dummy, Lambda, symbols, Interval, Intersection, Set,
EmptySet, FiniteSet, Union, ComplexRegion, Mul)
from sympy.multipledispatch import dispatch
from sympy.sets.conditionset import ConditionSet
from sympy.sets.fancysets import (Integers, Naturals, Reals, Range,
ImageSet, Rat... |
df67cb5958d56936ac2c410a14ea4bb7809a2e91e2ddd8e486aa5206dc78e42e |
from sympy.core.expr import unchanged
from sympy.sets.fancysets import (ImageSet, Range, normalize_theta_set,
ComplexRegion)
from sympy.sets.sets import (FiniteSet, Interval, Union, imageset,
Intersection, ProductSet, Contains)
from sympy.sets.conditionset... |
54069084f9e1ac328c343a0fd5cd0f908b8e2a9331af1dbd6a790327bbf31e77 | #!/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... |
4108c624627a960e67a3aef36397c58e905529c9c2ceb4d0fd8f3e3d12a29932 | #!/usr/bin/env python
import os
import json
from subprocess import check_output
from collections import OrderedDict, defaultdict
from collections.abc import Mapping
import glob
from contextlib import contextmanager
import requests
from requests_oauthlib import OAuth2
def main(version, push=None):
"""
WARNIN... |
5b46c2e75f53e6f7e895a82c60c2856eb5e89010e5ad1e560a56f2d0e6cda151 | """
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... |
8bfd1c79b39c14ed581f6f60a0bb0b1260a10e603f9185a79af5c90a4a466718 | from __future__ import print_function, division
import random
import itertools
from typing import Sequence as tSequence, Union as tUnion, List as tList, Tuple as tTuple
from sympy import (Matrix, MatrixSymbol, S, Indexed, Basic, Tuple, Range,
Set, And, Eq, FiniteSet, ImmutableMatrix, Integer, igcd,... |
cb5929126f1529b31d999033bf50ad083aa974d96cba1382c7caddfe25311ae4 | from sympy import S, Basic, exp, multigamma, pi, prod
from sympy.core.sympify import sympify, _sympify
from sympy.matrices import (ImmutableMatrix, Inverse, Trace, Determinant,
MatrixSymbol, MatrixBase, Transpose, MatrixSet,
matrix2numpy)
from sympy.stats.rv impor... |
ab60e1a82385b7d37cdee6b1a1da6b8b72442e192ea55507aa80f7d0d6b1a706 | from sympy import (sympify, S, pi, sqrt, exp, Lambda, Indexed, besselk, gamma, Interval,
Range, factorial, Mul, Integer,
Add, rf, Eq, Piecewise, ones, Symbol, Pow, Rational, Sum,
Intersection, Matrix, symbols, Product, IndexedBase)
from sympy.matrices import Immu... |
75063081da48fdf8d9e30bd59f5001082e8b9c0e743ce153916095c89ff4882b | """
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... |
f98302c087a28daed6e01c0b572cfb12e1b76564809d14c77b4ebac566aa8ff9 | """
Joint Random Variables Module
See Also
========
sympy.stats.rv
sympy.stats.frv
sympy.stats.crv
sympy.stats.drv
"""
from sympy import (Basic, Lambda, sympify, Indexed, Symbol, ProductSet, S,
Dummy, prod)
from sympy.concrete.products import Product
from sympy.concrete.summations import Sum, summ... |
fa5f027f34d7ba2709d9a9dbe7f6e084e462b2a0900b1364c41ae0e1dcf2435c | import itertools
from sympy import (Expr, Add, Mul, S, Integral, Eq, Sum, Symbol,
expand as _expand, Not)
from sympy.core.compatibility import default_sort_key
from sympy.core.parameters import global_parameters
from sympy.core.sympify import _sympify
from sympy.core.relational import Relational
fr... |
eedba592ddc25699c366bc4cd6585366004549aa6ea2cce70b6d8f02c21e283f | 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()
#----------------------------------------------------------------------------#
# ... |
9db508dc1c221c18a05805764cb0189124d0a3287cb6791790a561839e9919bc | """
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... |
5dda2069b63640692c8b3ec24c1b028d7f739f72a967af3371c8881910d5082c | from sympy import Integer, Rational, Tuple
import sympy.polys
from math import gcd
def egyptian_fraction(r, algorithm="Greedy"):
"""
Return the list of denominators of an Egyptian fraction
expansion [1]_ of the said rational `r`.
Parameters
==========
r : Rational or (p, q)
a positi... |
6be789fe450a7e3c843861386fb9b99c223c39629734db06498d3efb716b0399 | from sympy.combinatorics.permutations import Permutation, _af_rmul, \
_af_invert, _af_new
from sympy.combinatorics.perm_groups import PermutationGroup, _orbit, \
_orbit_transversal
from sympy.combinatorics.util import _distribute_gens_by_base, \
_orbits_transversals_from_bsgs
"""
References for tensor ... |
e42e170d72b3ca4191b63c34dda69cd33d915482c822bb830de24744c225e61c | """
Limits
======
Implemented according to the PhD thesis
http://www.cybertester.com/data/gruntz.pdf, which contains very thorough
descriptions of the algorithm including many examples. We summarize here
the gist of it.
All functions are sorted according to how rapidly varying they are at
infinity using the followin... |
a5c6d22a9a2fce806bb8a8c6129435c337181e12fba25cfd4641fe78f6d937a2 | from sympy.core import S, Symbol, Add, sympify, Expr, PoleError, Mul
from sympy.core.exprtools import factor_terms
from sympy.functions.combinatorial.factorials import factorial
from sympy.functions.special.gamma_functions import gamma
from sympy.polys import PolynomialError, factor
from sympy.series.order import Order... |
e7a95cc40e376044a2476df78257c480c8d0a523e6b7dafa3b7573de8fb7d782 | """Fourier Series"""
from sympy import pi, oo, Wild
from sympy.core.expr import Expr
from sympy.core.add import Add
from sympy.core.compatibility import is_sequence
from sympy.core.containers import Tuple
from sympy.core.singleton import S
from sympy.core.symbol import Dummy, Symbol
from sympy.core.sympify import symp... |
a269480262d4ecccee7ccdcea42a3afaed83219d8fb0ad2835b02ccb6c9867ec | """Formal Power Series"""
from collections import defaultdict
from sympy import oo, zoo, nan
from sympy.core.add import Add
from sympy.core.compatibility import iterable
from sympy.core.expr import Expr
from sympy.core.function import Derivative, Function, expand
from sympy.core.mul import Mul
from sympy.core.numbers... |
6bade01c85157a3a6d40e556656789d1e05d86807abf0c6a0a54e818773435fe | from sympy.core import S, sympify, Expr, Rational, Dummy
from sympy.core import Add, Mul, expand_power_base, expand_log
from sympy.core.cache import cacheit
from sympy.core.compatibility import default_sort_key, is_sequence
from sympy.core.containers import Tuple
from sympy.sets.sets import Complement
from sympy.utilit... |
7ca5746fe81331ce931bee85e213b32c567c6f84b66db77cbfc8c7ac91baff4c | from collections import defaultdict
from sympy import SYMPY_DEBUG
from sympy.core import expand_power_base, sympify, Add, S, Mul, Derivative, Pow, symbols, expand_mul
from sympy.core.add import _unevaluated_Add
from sympy.core.compatibility import iterable, ordered, default_sort_key
from sympy.core.parameters import ... |
2aa6066e14974355491397b0c9a0f42657e04ea3376e470b4f26033779974763 | """ Tools for doing common subexpression elimination.
"""
from sympy.core import Basic, Mul, Add, Pow, sympify, Symbol
from sympy.core.compatibility import iterable
from sympy.core.containers import Tuple, OrderedSet
from sympy.core.exprtools import factor_terms
from sympy.core.function import _coeff_isneg
from sympy.c... |
52e87d15d522475998a0638495fb4ce8f8f1b9428f74e8fe24caa43a0789e98e | from collections import defaultdict
from sympy.core.add import Add
from sympy.core.basic import S
from sympy.core.compatibility import ordered
from sympy.core.expr import Expr
from sympy.core.exprtools import Factors, gcd_terms, factor_terms
from sympy.core.function import expand_mul
from sympy.core.mul import Mul
fro... |
192beedd92edc1db817dfc1dee8e2932f5cbf122e796a4e97999e93b3201f937 | # References :
# http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/
# https://en.wikipedia.org/wiki/Quaternion
from sympy import S, Rational
from sympy import re, im, conjugate, sign
from sympy import sqrt, sin, cos, acos, exp, ln
from sympy import trigsimp
from sympy import integrate
from sympy... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.