hash stringlengths 64 64 | content stringlengths 0 1.51M |
|---|---|
218a9b36e89d6f7aa788e7a6eb3bb43fe5a74ace1a22e66ef12f36ae9002cf33 | """Implementation of :class:`QuotientRing` class."""
from sympy.polys.agca.modules import FreeModuleQuotientRing
from sympy.polys.domains.ring import Ring
from sympy.polys.polyerrors import NotReversible, CoercionFailed
from sympy.utilities import public
# TODO
# - successive quotients (when quotient ideals are impl... |
5ade7fcbb1d30def2ed6a19a9613614d3ed1c3709089592681db90ee37290fd7 | """Implementation of :class:`RealField` class. """
from sympy.core.numbers import Float
from sympy.polys.domains.field import Field
from sympy.polys.domains.simpledomain import SimpleDomain
from sympy.polys.domains.characteristiczero import CharacteristicZero
from sympy.polys.domains.mpelements import MPContext
from ... |
c7c04f9062a3d163eec09ccdda9cb997d6808c7698e1d8efeb9738b73513af76 | """Implementation of :class:`PythonRationalField` class. """
from sympy.polys.domains.groundtypes import PythonInteger, PythonRational, SymPyRational
from sympy.polys.domains.rationalfield import RationalField
from sympy.polys.polyerrors import CoercionFailed
from sympy.utilities import public
@public
class PythonRa... |
e477003608edb5c0661c1686353ebb153c0429ad516d7ae54d7f76d307e27c05 | """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... |
ea509c88ec0c6008e55048a6cef9f8b928d2153c9aa732a1b0572b65987eaf41 | """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):... |
5034f1e28b00604dc2b2977140d02204d37feef1a79a75ff33aa4752de9a6e17 | """Implementation of :class:`IntegerRing` class. """
from sympy.external.gmpy import MPZ, HAS_GMPY
from sympy.polys.domains.groundtypes import (
SymPyInteger,
factorial,
gcdex, gcd, lcm, sqrt,
)
from sympy.polys.domains.characteristiczero import CharacteristicZero
from sympy.polys.domains.ring import Rin... |
d868de34c79b4d7c4b1c390a62a6eb3fe859a815c7a1cfd4bfb924ef12323dcc | """Implementation of :class:`ComplexField` class. """
from sympy.core.numbers import Float, I
from sympy.polys.domains.characteristiczero import CharacteristicZero
from sympy.polys.domains.field import Field
from sympy.polys.domains.mpelements import MPContext
from sympy.polys.domains.simpledomain import SimpleDomain... |
c37709713edaa8b2c79f77e01710b9fe51b0b96b0214978b7e8abefc43c3d8f6 | """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):... |
81e47de0c7a489d9bbdb6578ed1a0a303af23505bc0cbffca5129a35f85f2742 | """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... |
d2f7764242e2daae27a62b38c11d703057c7185197abb2c97be90951df0e61cd | """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
... |
7580b76333fa009aa668ca30d2adbdc5b847dd78e8b8a1639bb222f47d5a10d7 | """Ground types for various mathematical domains in SymPy. """
import builtins
from sympy.external.gmpy import HAS_GMPY, factorial, sqrt
PythonInteger = builtins.int
PythonReal = builtins.float
PythonComplex = builtins.complex
from .pythonrational import PythonRational
from sympy.core.numbers import (
igcdex as... |
53a3e1d7fe44cf96d737825c1764ecab51540c4c18b06c749d44fe8190ef3b95 | """Implementation of :class:`GMPYIntegerRing` class. """
from sympy.polys.domains.groundtypes import (
GMPYInteger, SymPyInteger,
factorial as gmpy_factorial,
gmpy_gcdex, gmpy_gcd, gmpy_lcm, sqrt as gmpy_sqrt,
)
from sympy.polys.domains.integerring import IntegerRing
from sympy.polys.polyerrors import Coe... |
aa9b463dddb40f744cecae51473098df801cf7a775bd4a54b691f7ae6692efcf | """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... |
362c97c49bcc9fc873a0d0f509fea6bc747651ce7fe5222909797d8351392e35 | """Tests for the implementation of RootOf class and related tools. """
from sympy.polys.polytools import Poly
from sympy.polys.rootoftools import (rootof, RootOf, CRootOf, RootSum,
_pure_key_dict as D)
from sympy.polys.polyerrors import (
MultivariatePolynomialError,
GeneratorsNeeded,
PolynomialError,... |
c0d182603659e0bea6d4748f157f72a71503e754796730345e39ea25db4ee171 | """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... |
bd8325393b98bdffb5e4fd27293166fae46b85473e9c214492a60500f2f1834f | """Tests for PythonRational type. """
from sympy.polys.domains import PythonRational as QQ
from sympy.testing.pytest import raises
def test_PythonRational__init__():
assert QQ(0).numerator == 0
assert QQ(0).denominator == 1
assert QQ(0, 1).numerator == 0
assert QQ(0, 1).denominator == 1
assert QQ(... |
aa19912a11188068ebd96a71c4a018295d7c036e08a7850c1ba4772d27ee5322 | """Tests for algorithms for computing symbolic roots of polynomials. """
from sympy import (S, symbols, Symbol, Wild, Rational, sqrt,
powsimp, sin, cos, pi, I, Interval, re, im, exp, ZZ, Piecewise,
acos, root, conjugate)
from sympy.polys import Poly, cyclotomic_poly, intervals, nroots, rootof
from sympy.poly... |
bf75662965d07b23eec0d1b28b37d1e9915be0691167def14441dac2e2d6aa98 | """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... |
076724f1ec36ec8e7c15508f2511dec861a11f96c869b9f240c80755d8df5339 | """
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 ... |
298d396d5ff9d44640d9daf41cb09f76c2b74ae47690f0e3a26de72c28c5afbc | """
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... |
2d576c0c6f0c3f59c001de18c2ea57fc26b83fbb604c7a9846178886953e0232 | #
# 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... |
39257f813b0ea64e90e7e503b5398494b0256e72f20ec5e47427948946cee90b | """
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):
"""Sparse matrix based on polys domain elements
This is a dict subclass and is a wra... |
30411671308c12a6c96b142fa347f95d05636a57d3ba51ccca71d5176938f568 | """
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... |
a6f202588f3faffbac6b4105aa56f3ec8f004b328c2b68f6827fbae4299348f5 | """
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... |
bfcc642b7982f7e43cfaa4ea2afc886e9479ca810e9c38ee2a3ef4df0b332ccc | """
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... |
8ebbb84b84e4fee1b24795fab8198491d1b566be34b59d91c6a86b511ac1ffd6 | """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.core.compatibility import HAS_GMPY
from sympy.polys.domains import (ZZ, QQ, RR, CC, FF, GF, EX, ZZ_gmpy,
ZZ_pyt... |
283b84b55bb47012b17b2fb0b4fc590e92d82c34b8e10375f11a922f07546711 | """
Tests for the sympy.polys.matrices.eigen module
"""
from sympy import S, Matrix, sqrt
from sympy.polys.agca.extensions import FiniteExtension
from sympy.polys.domains import QQ
from sympy.polys.polytools import Poly
from sympy.polys.rootoftools import CRootOf
from sympy.polys.matrices.domainmatrix import DomainMa... |
05e5b55e50d9168d646768470bb66bbd47c0c4c34a953125e50f48a9ce9b7b01 | 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():
... |
8f77f42cfb6f618ba5bfc5b5956a97bdd3771c915c43b9a91965a12773754da5 | 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))
raise... |
646473dd030415d86398ef3f39b9dc2d02aa9b071bea10bbe459fae2478e2462 | 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... |
ad62603a61c44c793c938020814c11eaf3387bcff91310c22a05430af1d93a07 | #
# test_linsolve.py
#
# Test the internal implementation of linsolve.
#
from sympy import S
from sympy.abc import x
from sympy.polys.matrices.linsolve import _linsolve
def test__linsolve():
assert _linsolve([], [x]) == {x:x}
assert _linsolve([S.Zero], [x]) == {x:x}
|
4af3be6557fae3a948f8cc5344c1b00d1c9722c9478a75adf4a27cbf47495e67 | """
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... |
df2432ae4f417eea0d22ded314695e2ee54ba0be65bc433e302ccc456cf8b054 | from sympy import Add, Basic, symbols, Symbol, And, S
from sympy.core.symbol import Str
from sympy.unify.core import Compound, Variable
from sympy.unify.usympy import (deconstruct, construct, unify, is_associative,
is_commutative)
from sympy.abc import x, y, z, n
def test_deconstruct():
expr = Basic(1,... |
180d43ec78ee00c3137508dfcdf7dd3a853809e4455d5d0881d942bb89939901 | from sympy import sin, cos, pi, S, sqrt
from sympy.testing.pytest import raises
from sympy.vector.coordsysrect import CoordSys3D
from sympy.vector.integrals import ParametricIntegral, vector_integrate
from sympy.vector.parametricregion import ParametricRegion
from sympy.vector.implicitregion import ImplicitRegion
from ... |
d338aab6aa5fce70f1a5cf31ed79a6a88da2732a8f973678aba5e4fcedf47df1 | from sympy import Eq, Rational, S, Symbol, symbols, pi, sqrt, oo, Point2D, Segment2D, Abs, sec
from sympy.geometry import (Circle, Ellipse, GeometryError, Line, Point,
Polygon, Ray, RegularPolygon, Segment,
Triangle, intersection)
from sympy.testing.pytest import ... |
dd4e38acea08620865aebea176369f0577859ff08f2fca81d315aad90ee644bc | import sympy
from sympy.parsing.sympy_parser import (
parse_expr,
standard_transformations,
convert_xor,
implicit_multiplication_application,
implicit_multiplication,
implicit_application,
function_exponentiation,
split_symbols,
split_symbols_custom,
_token_splittable
)
from symp... |
5ec745f0191c5337aca7c123e2b1802075a3132ad9f91bb3f3f6f60b1b90caef | # -*- 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... |
b41f15d579b2669bac0aef45a8b71ab19d520eb14c3c6501f6b3dd7934e6e5eb | 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,... |
3f95d3a365239320f2c7877d929996226e81a025f23a2103f6cf13af7c37026e | import collections
import warnings
from sympy.external import import_module
autolevparser = import_module('sympy.parsing.autolev._antlr.autolevparser',
import_kwargs={'fromlist': ['AutolevParser']})
autolevlexer = import_module('sympy.parsing.autolev._antlr.autolevlexer',
... |
27353aa5c529c6f31b1aa66ac506c9a63140dcea76a4d7f983de801b18304710 | from sympy.external import import_module
from sympy.utilities.decorator import doctest_depends_on
@doctest_depends_on(modules=('antlr4',))
def parse_autolev(autolev_code, include_numeric=False):
"""Parses Autolev code (version 4.1) to SymPy code.
Parameters
=========
autolev_code : Can be an str or an... |
f76dc4aaa21de29b811ba56c1f6cf7177e51d3ea318a5bf72fba5dc13ee3ffb7 | # 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... |
7882841731309021613c5d064e67fa48bbb15d3dfce06a9d0899e188bd94d014 | import sympy.physics.mechanics as _me
import sympy as _sm
import math as m
import numpy as _np
f = _sm.S(3)
g = _sm.S(9.81)
a, b = _sm.symbols('a b', real=True)
s, s1 = _sm.symbols('s s1', real=True)
s2, s3 = _sm.symbols('s2 s3', real=True, nonnegative=True)
s4 = _sm.symbols('s4', real=True, nonpositive=True)
k1, k2, ... |
235b6c41c4805bac2a220b85fbb970963f43e1867c90266a3ea4ca3d41d1f682 | import sympy.physics.mechanics as _me
import sympy as _sm
import math as m
import numpy as _np
x, y = _me.dynamicsymbols('x y')
a, b = _sm.symbols('a b', real=True)
e = a*(b*x+y)**2
m = _sm.Matrix([e,e]).reshape(2, 1)
e = e.expand()
m = _sm.Matrix([i.expand() for i in m]).reshape((m).shape[0], (m).shape[1])
e = _sm.fa... |
3b72b7210a3e1c28c020e4a47f3ddb0e5b2dedd554891c21399d2aff78dbe4b5 | import sympy.physics.mechanics as _me
import sympy as _sm
import math as m
import numpy as _np
frame_a = _me.ReferenceFrame('a')
frame_b = _me.ReferenceFrame('b')
frame_n = _me.ReferenceFrame('n')
x1, x2, x3 = _me.dynamicsymbols('x1 x2 x3')
l = _sm.symbols('l', real=True)
v1 = x1*frame_a.x+x2*frame_a.y+x3*frame_a.z
v2... |
bc43b48cc383f8a21ebc07157b19a9bda7343068cdecefdd362a4e04924dcc5d | import sympy.physics.mechanics as _me
import sympy as _sm
import math as m
import numpy as _np
q1, q2 = _me.dynamicsymbols('q1 q2')
x, y, z = _me.dynamicsymbols('x y z')
e = q1+q2
a = (e).subs({q1:x**2+y**2, q2:x-y})
e2 = _sm.cos(x)
e3 = _sm.cos(x*y)
a = (e2).series(x, 0, 2).removeO()
b = (e3).series(x, 0, 2).removeO(... |
f2d81bc09fa2af4c22382b20205080bb8b83f1289e611acba0bcc47da7b96106 | import sympy.physics.mechanics as _me
import sympy as _sm
import math as m
import numpy as _np
frame_a = _me.ReferenceFrame('a')
c1, c2, c3 = _sm.symbols('c1 c2 c3', real=True)
a = _me.inertia(frame_a, 1, 1, 1)
particle_p1 = _me.Particle('p1', _me.Point('p1_pt'), _sm.Symbol('m'))
particle_p2 = _me.Particle('p2', _me.P... |
1ada95f96ab61862737db94cb1c033f8a5c2cecd0fff85eabc0dc521d94f7b4e | import sympy.physics.mechanics as _me
import sympy as _sm
import math as m
import numpy as _np
frame_n = _me.ReferenceFrame('n')
frame_a = _me.ReferenceFrame('a')
a = 0
d = _me.inertia(frame_a, 1, 1, 1)
point_po1 = _me.Point('po1')
point_po2 = _me.Point('po2')
particle_p1 = _me.Particle('p1', _me.Point('p1_pt'), _sm.S... |
fd7bccacc7b9afd44ba294eb22a3062e1698bc72f5aa3b5e5b3f4229ca2d08bf | import sympy.physics.mechanics as _me
import sympy as _sm
import math as m
import numpy as _np
x, y = _me.dynamicsymbols('x y')
x_d, y_d = _me.dynamicsymbols('x_ y_', 1)
e = _sm.cos(x)+_sm.sin(x)+_sm.tan(x)+_sm.cosh(x)+_sm.sinh(x)+_sm.tanh(x)+_sm.acos(x)+_sm.asin(x)+_sm.atan(x)+_sm.log(x)+_sm.exp(x)+_sm.sqrt(x)+_sm.fa... |
646dfab373e7913d1a28133d371e87d2c749aeda0bc1a79b53ddfce98494aa5f | import sympy.physics.mechanics as _me
import sympy as _sm
import math as m
import numpy as _np
x, y = _me.dynamicsymbols('x y')
a, b, r = _sm.symbols('a b r', real=True)
eqn = _sm.Matrix([[0]])
eqn[0] = a*x**3+b*y**2-r
eqn = eqn.row_insert(eqn.shape[0], _sm.Matrix([[0]]))
eqn[eqn.shape[0]-1] = a*_sm.sin(x)**2+b*_sm.co... |
5af52d9e8d43dc1ae614d3d860804a47f80e03e3da1e8c4b9524cd0d7ebb75c4 | import sympy.physics.mechanics as _me
import sympy as _sm
import math as m
import numpy as _np
x, y = _me.dynamicsymbols('x y')
x_d, y_d = _me.dynamicsymbols('x_ y_', 1)
e1 = (x+y)**2+(x-y)**3
e2 = (x-y)**2
e3 = x**2+y**2+2*x*y
m1 = _sm.Matrix([e1,e2]).reshape(2, 1)
m2 = _sm.Matrix([(x+y)**2,(x-y)**2]).reshape(1, 2)
m... |
587a1de72cca1784cd6c47f861fc66c7d5a78a603b34e5eab538d95d1f05b0fd | import sympy.physics.mechanics as _me
import sympy as _sm
import math as m
import numpy as _np
frame_a = _me.ReferenceFrame('a')
frame_b = _me.ReferenceFrame('b')
q1, q2, q3 = _me.dynamicsymbols('q1 q2 q3')
frame_b.orient(frame_a, 'Axis', [q3, frame_a.x])
dcm = frame_a.dcm(frame_b)
m = dcm*3-frame_a.dcm(frame_b)
r = _... |
7584d1b57bcc0d71e22b35c70f64a1d1f704ba4a1bdf0aff19b49ea9a66bacef | import sympy.physics.mechanics as _me
import sympy as _sm
import math as m
import numpy as _np
x, y = _me.dynamicsymbols('x y')
a11, a12, a21, a22, b1, b2 = _sm.symbols('a11 a12 a21 a22 b1 b2', real=True)
eqn = _sm.Matrix([[0]])
eqn[0] = a11*x+a12*y-b1
eqn = eqn.row_insert(eqn.shape[0], _sm.Matrix([[0]]))
eqn[eqn.shap... |
8eb25f6f4264d853f8192e690dad14079a61d228c455dd57f2678a799ad35678 | import sympy.physics.mechanics as _me
import sympy as _sm
import math as m
import numpy as _np
x1, x2 = _me.dynamicsymbols('x1 x2')
f1 = x1*x2+3*x1**2
f2 = x1*_me.dynamicsymbols._t+x2*_me.dynamicsymbols._t**2
x, y = _me.dynamicsymbols('x y')
x_d, y_d = _me.dynamicsymbols('x_ y_', 1)
y_dd = _me.dynamicsymbols('y_', 2)
... |
152bb84cfd810d3423cd884c91ca518576dbde4003dbb5c2c8efc4a0be7901c9 | import sympy.physics.mechanics as _me
import sympy as _sm
import math as m
import numpy as _np
g, lb, w, h = _sm.symbols('g lb w h', real=True)
theta, phi, omega, alpha = _me.dynamicsymbols('theta phi omega alpha')
theta_d, phi_d, omega_d, alpha_d = _me.dynamicsymbols('theta_ phi_ omega_ alpha_', 1)
theta_dd, phi_dd =... |
0ddc5c5ab9b71cc42ecb26373e4eac2876f845785010cfc4298dc761908ff1e7 | import sympy.physics.mechanics as _me
import sympy as _sm
import math as m
import numpy as _np
q1, q2 = _me.dynamicsymbols('q1 q2')
q1_d, q2_d = _me.dynamicsymbols('q1_ q2_', 1)
q1_dd, q2_dd = _me.dynamicsymbols('q1_ q2_', 2)
l, m, g = _sm.symbols('l m g', real=True)
frame_n = _me.ReferenceFrame('n')
point_pn = _me.Po... |
b94f5acd3506ad8d790520edc394ff57eee09a3ca11db5ec973926c01bc58c69 | import sympy.physics.mechanics as _me
import sympy as _sm
import math as m
import numpy as _np
q1, q2, u1, u2 = _me.dynamicsymbols('q1 q2 u1 u2')
q1_d, q2_d, u1_d, u2_d = _me.dynamicsymbols('q1_ q2_ u1_ u2_', 1)
l, m, g = _sm.symbols('l m g', real=True)
frame_n = _me.ReferenceFrame('n')
frame_a = _me.ReferenceFrame('a... |
f5178202a7141f91d80601e6a29f61e59c79e267d271664de4be45eab087938c | import sympy.physics.mechanics as _me
import sympy as _sm
import math as m
import numpy as _np
m, k, b, g = _sm.symbols('m k b g', real=True)
position, speed = _me.dynamicsymbols('position speed')
position_d, speed_d = _me.dynamicsymbols('position_ speed_', 1)
o = _me.dynamicsymbols('o')
force = o*_sm.sin(_me.dynamics... |
e1fbafbfbe870792072d3d45b65f55008fb748b943d3a9ff3c7e619e17ac96ea | from collections import deque
from random import randint
from sympy.external import import_module
from sympy import Mul, Basic, Number, Pow, Integer
from sympy.physics.quantum.represent import represent
from sympy.physics.quantum.dagger import Dagger
__all__ = [
# Public interfaces
'generate_gate_rules',
... |
394d305ac5d216f86b1738d6b09e9c97737c0747c775caf8c2ec0035282ed151 | """
Definition of physical dimensions.
Unit systems will be constructed on top of these dimensions.
Most of the examples in the doc use MKS system and are presented from the
computer point of view: from a human point, adding length to time is not legal
in MKS but it is in natural system; for a computer in natural sys... |
4fc2c0d8144d141dae7af740debbeca855e197dcafe929c8f89f33644b02a838 | from .vector import Vector, _check_vector
from .frame import _check_frame
from warnings import warn
__all__ = ['Point']
class Point:
"""This object represents a point in a dynamic system.
It stores the: position, velocity, and acceleration of a point.
The position is a vector defined as the vector dista... |
fb7b2fd593bb85a17c0a88a8c88d0d90ffc251a13283b495d245b92e9fd55c52 | 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
__all__ = ['C... |
e884211e08c8fb90338bf6ff7afd9d11fe3695a8bce9dd7c8c7328cf48157632 | """
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... |
d149aa22ddbebbc5b036402ab27395b7d565901f4ad024482588906a5b49ef7c | __all__ = [
'TWave',
'RayTransferMatrix', 'FreeSpace', 'FlatRefraction', 'CurvedRefraction',
'FlatMirror', 'CurvedMirror', 'ThinLens', 'GeometricRay', 'BeamParameter',
'waist2rayleigh', 'rayleigh2waist', 'geometric_conj_ab',
'geometric_conj_af', 'geometric_conj_bf', 'gaussian_conj',
'conjugate_... |
c46c16ad746bce2c297370e86c6f72b3c0d486f1422c4839f67141a0f2b291f3 | """
This module has all the classes and functions related to waves in optics.
**Contains**
* TWave
"""
__all__ = ['TWave']
from sympy import (sympify, pi, sin, cos, sqrt, Number, Symbol, S,
symbols, Derivative, atan2)
from sympy.core.expr import Expr
from sympy.physics.units import speed_of_light, meter, second... |
7e051180d522bb483346382e5847414ae10172fca94ae8f440d83b68f9e83398 | from sympy.physics.units.systems.si import dimsys_SI
from sympy import S, Symbol, sqrt, cos, acos, log, atan2, pi, Abs
from sympy.physics.units.dimensions import Dimension
from sympy.physics.units.definitions.dimension_definitions import (
length, time, mass, force, pressure, angle
)
from sympy.physics.units impor... |
42bbe6f56c6eb4ee6df93e035e015ee1cd035d3f429b06e29e368cab10200d7e | 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... |
24c60ca9b04cdf262ea908896f9c9ed0c73b0ce108951e66c8c19d99a676fcb1 | from sympy import (symbols, Symbol, pi, sqrt, cos, sin, Derivative,
Function, simplify, I, atan2)
from sympy.abc import epsilon, mu
from sympy.functions.elementary.exponential import exp
from sympy.physics.units import speed_of_light, m, s
from sympy.physics.optics import TWave
from sympy.testing.pytest import rai... |
08b734e38bd0e2193696c33f5e7a1200916a51ac205f43145a3c105a48745eab | 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... |
3923d4d76063552658500bd97bd3525f6d7429f02a0024c0ee44ee7dd2fa3d62 | from collections import defaultdict
from sympy import Sum, Mul, KroneckerDelta, Indexed, IndexedBase, Add
from sympy.combinatorics import Permutation
from sympy.matrices.expressions.matexpr import MatrixElement
from sympy.tensor.array.expressions.array_expressions import PermuteDims, ArrayDiagonal, \
ArrayContract... |
ac3f3e25aede3afc79729b8754e69651f712d8c689ce1d06e07d8c90bf31d477 | import itertools
from typing import Tuple
from functools import reduce, singledispatch
from itertools import accumulate
from sympy import S, Trace, MatrixExpr, Transpose, DiagMatrix, Mul, ZeroMatrix
from sympy.combinatorics.permutations import _af_invert, Permutation
from sympy.matrices.common import MatrixCommon
from... |
8aa8d435687a227720b01e5ed7e23a6fff579c8878bbb9f67bae6b94cbd311da | from sympy import Mul, Basic, MatMul, MatAdd, Transpose, Trace, Pow, \
MatPow, symbols, Dummy, Lambda, HadamardProduct, HadamardPower, S
from sympy.matrices.expressions.matexpr import MatrixExpr
from sympy.tensor.array.expressions.array_expressions import ArrayDiagonal, ArrayTensorProduct, \
PermuteDims, ArrayA... |
24ca4df9ba9c8646768c8fc6b018c3cce2f7a3c492391ed19220db84eb5869d2 | import bisect
from collections import defaultdict
from sympy import Tuple, Integer
def _get_mapping_from_subranks(subranks):
mapping = {}
counter = 0
for i, rank in enumerate(subranks):
for j in range(rank):
mapping[counter] = (i, j)
counter += 1
return mapping
def _... |
54c4c1da12f2d637692a7d1d3988af4f300dcea2ab73c02da9e3052aac049ab8 | import operator
from functools import reduce
import itertools
from itertools import accumulate
from sympy import Expr, ImmutableDenseNDimArray, S, Symbol, Integer, ZeroMatrix, Basic, tensorproduct, Add, permutedims, \
Tuple, tensordiagonal, Lambda, Dummy, Function, MatrixExpr, NDimArray, Indexed, IndexedBase, defa... |
e4fa93730e54beaed8274f49af2b642b84ff4fcac152a952411d92da5b99c038 | import operator
from functools import reduce, singledispatch
from sympy import Expr, Transpose, Identity, MatrixSymbol, S, Inverse, MatrixExpr, HadamardProduct
from sympy.combinatorics.permutations import _af_invert
from sympy.matrices.expressions.applyfunc import ElementwiseApplyFunction
from sympy.tensor.array.expre... |
dae68711529a978d7b2c060348923515bd3a0d2e76a663ef77e49f3d0e5caed0 | from sympy import (
symbols, Identity, cos, ZeroMatrix)
from sympy.tensor.array.expressions.conv_matrix_to_array import convert_matrix_to_array
from sympy.tensor.array.expressions.conv_array_to_matrix import _support_function_tp1_recognize, \
_array_diag2contr_diagmatrix, convert_array_to_matrix, _remove_trivia... |
74496453b9a25e65fa19d278a5fe796f0b2ac948866f3e6466a435c572e4a5ac | from sympy import ImmutableDenseNDimArray, tensorproduct, MatrixSymbol, tensorcontraction, tensordiagonal, permutedims, \
Symbol
from sympy.tensor.array.expressions.array_expressions import ZeroArray, OneArray, ArraySymbol, \
ArrayTensorProduct, PermuteDims, ArrayDiagonal, ArrayContraction
from sympy.testing.py... |
983786d5091893814288a971135dc76211a040983f23e6118bd681b0a50c07bd | from sympy import Sum, MatrixSymbol, Identity, symbols, IndexedBase, KroneckerDelta
from sympy.combinatorics import Permutation
from sympy.tensor.array.expressions.array_expressions import ArrayContraction, ArrayTensorProduct, \
ArrayDiagonal, ArrayAdd, PermuteDims
from sympy.tensor.array.expressions.conv_array_to_... |
364e2373f49b93951523eaa74513c4d3ef5473692c40d426ce3b4f1b4d0008a6 | from sympy import MatrixSymbol, Transpose, Inverse, Trace, HadamardProduct, HadamardPower, MatPow, symbols, Identity
from sympy.tensor.array.expressions.array_expressions import ArrayTensorProduct, ArrayContraction, \
PermuteDims, ArrayDiagonal
from sympy.tensor.array.expressions.conv_array_to_matrix import convert... |
efadfcef79b93fe1375d53f9798ba63372e8e1eb1bba5401fd664e9b7c363c82 | import random
from sympy import symbols, ImmutableDenseNDimArray, tensorproduct, tensorcontraction, permutedims, MatrixSymbol, \
ZeroMatrix, sin, cos, DiagMatrix
from sympy.combinatorics import Permutation
from sympy.tensor.array.expressions.array_expressions import ZeroArray, OneArray, ArraySymbol, ArrayElement, ... |
3dfe0ca9efd8f01376d0e84182b10d045aea61f8d70a4b19b183ad8fed115c94 | from sympy import MatrixSymbol, symbols, Identity, sin, cos
from sympy.matrices.expressions.applyfunc import ElementwiseApplyFunction
from sympy.tensor.array.expressions.array_expressions import ArraySymbol, ArrayTensorProduct, \
PermuteDims, ArrayDiagonal, ArrayElementwiseApplyFunc, ArrayContraction
from sympy.ten... |
3b8bf20b61137bd7686645138f3f181f155e77c453b03af77704d638bb83f3ea | 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... |
722e58875b9ad2cb6959d1b7e77aa19a877b18a90f4e486ac6f140949892e789 | 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 ... |
4d55a7d056158e79b05f4839b3b119f2aa1d129213c9d19f8ee7296975e831f8 | 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.matrices import MatrixDeterminant
from sympy.matrices.common import NonSquareMatri... |
b5cc6cbc2ddfaedf49a0d374b80ddf9d3e683b5a8929b50bb9619831fc4f1c4f | from sympy.matrices.expressions import MatrixExpr
from sympy import MatrixBase, Dummy, Lambda, Function, FunctionClass
from sympy.core.sympify import sympify, _sympify
class ElementwiseApplyFunction(MatrixExpr):
r"""
Apply function to a matrix elementwise without evaluating.
Examples
========
It... |
fcc6710454cd42e9f42633cf2e81912c095d63fd3a1f2c5f1b5da9edcb0376ce | from sympy import Number
from sympy.core import Mul, Basic, sympify, S
from sympy.core.mul import mul
from sympy.functions import adjoint
from sympy.strategies import (rm_id, unpack, typed, flatten, exhaust,
do_one, new)
from sympy.matrices.common import ShapeError, NonInvertibleMatrixError
from sympy.matrices.... |
e39ea8ef53498da10e0975603f10da642aa8dd2d3429d1424c1a070ed8a08f70 | from sympy.matrices.common import NonSquareMatrixError
from .matexpr import MatrixExpr
from .special import Identity
from sympy.core import S
from sympy.core.sympify import _sympify
from sympy.matrices import MatrixBase
class MatPow(MatrixExpr):
def __new__(cls, base, exp, evaluate=False, **options):
bas... |
806e2e4d7e889b105f502c654efba789564b5f24b64640c21b8f6bc006066ba9 | 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... |
6a3603845e8e2523bc7c956de6d3ac15d8d8b97140d2cb217116746d76076afb | from sympy import Basic, Expr, sympify, S
from sympy.matrices.matrices import MatrixBase
from sympy.matrices.common import NonSquareMatrixError
class Trace(Expr):
"""Matrix Trace
Represents the trace of a matrix expression.
Examples
========
>>> from sympy import MatrixSymbol, Trace, eye
>>... |
31f8bd45ee55154f8c5abf7e8947bd6da756b09e4df325c8e1b6a0fc53963750 | from sympy.core import Mul, sympify
from sympy.matrices.common import ShapeError
from sympy.matrices.expressions.matexpr import MatrixExpr
from sympy.matrices.expressions.special import ZeroMatrix, OneMatrix
from sympy.strategies import (
unpack, flatten, condition, exhaust, rm_id, sort
)
def hadamard_product(*ma... |
d86cd8344899f36c2e160f8333075a188d26288006b3b755e23ed578be8fc8e3 | """
Some examples have been taken from:
http://www.math.uwaterloo.ca/~hwolkowi//matrixcookbook.pdf
"""
from sympy import (MatrixSymbol, Inverse, symbols, Determinant, Trace,
sin, exp, cos, tan, log, S, sqrt,
hadamard_product, DiagMatrix, OneMatrix,
HadamardProdu... |
1fc3db4b298a7770d6dabffdfeebb965fa1b52002b165be6be1fd7bef9554510 | from sympy import (KroneckerDelta, diff, Sum, Dummy, factor,
expand, zeros, gcd_terms, Eq, Symbol)
from sympy.core import (S, symbols, Add, Mul, SympifyError, Rational,
Function)
from sympy.functions import sin, cos, tan, sqrt, cbrt, exp
from sympy.simplify import simplify
from s... |
16d6dda53edb9a8253fc018442417f40386908f486453a41973c5dfd4bf459d8 | from sympy.core.symbol import symbols, Dummy
from sympy.matrices.expressions.applyfunc import ElementwiseApplyFunction
from sympy import Matrix, Lambda, MatrixSymbol, exp, MatMul, sin, simplify
from sympy.testing.pytest import raises
from sympy.matrices.common import ShapeError
X = MatrixSymbol("X", 3, 3)
Y = MatrixS... |
9112ada911427b236840a458687d4b9c1428fd20cfa245113851506082bde804 | from sympy import Set, symbols, exp, log, S, Wild, Dummy, oo, Float
from sympy.core import Expr, Add
from sympy.core.function import Lambda, _coeff_isneg, FunctionClass
from sympy.logic.boolalg import true
from sympy.multipledispatch import dispatch
from sympy.sets import (imageset, Interval, FiniteSet, Union, ImageSet... |
0e3f1e1ed7fe1cb938a66243015cbecce32d02536a19960ab1d06715a9aaf89c | from sympy.core.expr import unchanged
from sympy.sets.fancysets import (ImageSet, Range, normalize_theta_set,
ComplexRegion)
from sympy.sets.sets import (FiniteSet, Interval, imageset, Union,
Intersection, ProductSet, Contains)
from sympy.simplify.simplify ... |
4858b80f5dd95d42651293a7bc0060c68960db6116e793d2e9abc4670d8d81b3 | 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, ... |
e92afef2aa1c2f3e5a46b3aa9c303091b0a3891d812168e81b44c9f49125b7f5 | import os
from tempfile import TemporaryDirectory
from sympy import (
pi, sin, cos, Symbol, Integral, Sum, sqrt, log, exp, Ne, oo, LambertW, I,
meijerg, exp_polar, Piecewise, And, real_root)
from sympy.core.singleton import S
from sympy.core.sympify import sympify
from sympy.external import import_module
from ... |
03e08c41d7d90378b41fb2c35c558ed281e9760db26a09c4c6fa40a9a62a2668 | #!/usr/bin/env python
"""
Test that
from sympy import *
doesn't import anything other than SymPy, it's hard dependencies (mpmath), and
hard optional dependencies (gmpy2). Importing unnecessary libraries
can accidentally add hard dependencies to SymPy in the worst case, or at best
slow down the SymPy import time when ... |
da56bc53a156daed9aa1530f298b5f8b3cda5df377dda470e6cc65163a294916 | #!/usr/bin/env python
""" Update the ``ask_generated.py`` file.
This must be run each time ``known_facts()`` in ``assumptions.facts`` module
is changed.
Should be run from sympy root directory.
$ python bin/ask_update.py
"""
# hook in-tree SymPy into Python path, if possible
import os
import sys
isympy_path = os.... |
6ba4ffba65ae8a95846ce3e1836729eb6c1e54ea652aeb4fc52910211f0d367a | """
This module exports all latin and greek letters as Symbols, so you can
conveniently do
>>> from sympy.abc import x, y
instead of the slightly more clunky-looking
>>> from sympy import symbols
>>> x, y = symbols('x y')
Caveats
=======
1. As of the time of writing this, the names ``O``, ``S``, ``I``,... |
c9de18437fc320445f244969f2153afb86f086fe2c2066f13314839df0cd11f9 | """
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... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.