hash stringlengths 64 64 | content stringlengths 0 1.51M |
|---|---|
94de20e7266a43b76375f83492d1971f63d6e300be70f68838def84c1a9da7a8 | from __future__ import print_function, division
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 _me... |
e86e3693cd1718524e19c726786200353290089a373085d66a1003b7b7d4f906 | 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... |
de5ab563d36dfd4a6955a8efc1dd42a66b7f071326eea2e2123a0bdbdcff9db1 | #
# 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, Iterable, List, Optional, Type
from sympy.core import S
from sympy.core.exprtools import factor_terms
from sympy.core.expr import Expr
from sympy.core.functi... |
0dbe66354caf809f71d223db796aeb5a9fa233d9ec764ff4d65176cf14a19650 | 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... |
03621a1b8862fb2f4c864ce3dd80e2682bdfc248be5bf1d698c7af054d840c7a | from sympy import (
Abs, And, Derivative, Dummy, Eq, Float, Function, Gt, I, Integral,
LambertW, Lt, Matrix, Or, Poly, Q, Rational, S, Symbol, Ne,
Wild, acos, asin, atan, atanh, binomial, cos, cosh, diff, erf, erfinv, erfc,
erfcinv, exp, im, log, pi, re, sec, sin,
sinh, solve, solve_linear, sqrt, ss... |
194739571f687792478a01ef77be9c14b4246b92c39a4b979fbce6ad1e2b8a75 | from sympy import (acos, acosh, asinh, 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, hyper, integrate)
from sympy.solvers.ode import (classif... |
922676b22dc10de788021c4684a6619fdf1b66c36808b5ceba8d388f9faa7303 | #
# 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... |
f2107eceb32dfd97d11efadeeed0029418cd38e369eaadf592ba32d0d7e9282f | import glob
import os
import shutil
import subprocess
import sys
import tempfile
import warnings
from distutils.errors import CompileError
from distutils.sysconfig import get_config_var
from .runners import (
CCompilerRunner,
CppCompilerRunner,
FortranCompilerRunner
)
from .util import (
get_abspath, m... |
c0da37cac18c1c06a6aba393ed82e686f426fe5de4d45a1a757988c0947afc2c | """ Tests from Michael Wester's 1999 paper "Review of CAS mathematical
capabilities".
http://www.math.unm.edu/~wester/cas/book/Wester.pdf
See also http://math.unm.edu/~wester/cas_review.html for detailed output of
each tested system.
"""
from sympy import (Rational, symbols, Dummy, factorial, sqrt, log, exp, oo, zoo,... |
eda64c75ea3c5d3beb2536a5bb5d0b96195e234651884a1930305bb6d4940a1b | from __future__ import print_function, division
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 S... |
1b5b2cadb177f25a0eb3a2e6f9807dc364e24c170292bec771afa0a72c71ed09 | 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)
from sympy.combinatorics impo... |
053d913c52fcdc5afc129f693d6429d333dea4b380aa0a1e1f4e8118b0b24a3e | 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... |
0572e4462d6f87689fa965ab44b16b5258d6f64e0bda3b4ae61ef508d40c6962 | from sympy.tensor.toperators import PartialDerivative
from sympy import (
Abs, Chi, Ci, CosineTransform, Dict, Ei, Eq, FallingFactorial,
FiniteSet, Float, FourierTransform, Function, Indexed, IndexedBase, Integral,
Interval, InverseCosineTransform, InverseFourierTransform, Derivative,
InverseLaplaceTra... |
276a74ef13cc7e7cac2a43b483769dd055d271f4264c8d93894c95e9edf4a0b3 | import random
from sympy import symbols, Derivative
from sympy.codegen.array_utils import (CodegenArrayTensorProduct, CodegenArrayElementwiseAdd,
CodegenArrayPermuteDims, CodegenArrayDiagonal, parse_matrix_expression)
from sympy.core.relational import Eq, Ne, Ge, Gt, Le, Lt
from s... |
142488a0b2065f89d4c18c76aa1078941672e71eaa5d09cb8340ed6c201951a1 | from sympy import (
Piecewise, lambdify, Equality, Unequality, Sum, Mod, sqrt,
MatrixSymbol, BlockMatrix, Identity
)
from sympy import eye
from sympy.abc import x, i, j, a, b, c, d
from sympy.core import Pow
from sympy.codegen.matrix_nodes import MatrixSolve
from sympy.codegen.cfunctions import log1p, expm1, hy... |
07bef2bc9d6da22b96e9c054160e498fcc7c6c490ab49e64870dd7aaa591677e | # -*- 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, ... |
2894476fb9691ca4c19ad366ecddf3e9753cf742ed03dcdbd9217173567f4dbf | from sympy import (S, symbols, I, atan, log, Poly, sqrt, simplify,
integrate, Rational, Dummy)
from sympy.integrals.rationaltools import ratint, ratint_logpart, log_to_atan
from sympy.abc import a, b, x, t
half = S.Half
def test_ratint():
assert ratint(S.Zero, x) == 0
assert ratint(S(7), x) == 7*x
... |
0968f8df4ae26deb0b89204f41ff28787f5ba5044765376752733701da8846b8 | from sympy import (
Symbol, Wild, sin, cos, exp, sqrt, pi, Function, Derivative,
Integer, Eq, symbols, Add, I, Float, log, Rational,
Lambda, atan2, cse, cot, tan, S, Tuple, Basic, Dict,
Piecewise, oo, Mul, factor, nsimplify, zoo, Subs, RootOf,
AccumBounds, Matrix, zeros, ZeroMatrix)
from sympy.core.... |
ab7c157ce9247834a3ce9cc59b77be53782f68c9e7486a392390b14ba64047dd | 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... |
08a66522fa189a1e81c1e7210a68d0cdd7b1a887b74f73f05299807f20c5c4c5 | """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,... |
0d9d7e274f9d9e6d6a781aa7989e2d84e5c9c293eb9fe89f526480e69e9cef44 | from sympy import (Symbol, Wild, GreaterThan, LessThan, StrictGreaterThan,
StrictLessThan, pi, I, Rational, sympify, symbols, Dummy)
from sympy.core.symbol import uniquely_named_symbol, _symbol
from sympy.testing.pytest import raises
from sympy.core.symbol import disambiguate
def test_Symbol():
a = Symbol("a... |
ea3e57bb1d2d34157784be7989e7499445b1bcbf00c1830b98dc2360e2b55c6c | from sympy import symbols, sin, exp, cos, Derivative, Integral, Basic, \
count_ops, S, And, I, pi, Eq, Or, Not, Xor, Nand, Nor, Implies, \
Equivalent, MatrixSymbol, Symbol, ITE, Rel, Rational, Sum
from sympy.core.containers import Tuple
x, y, z = symbols('x,y,z')
a, b, c = symbols('a,b,c')
def test_count_ops_... |
0081ba2b1f1a25c5eb2c3cb72f4b034470c4f9f770c699d7cf90c8ab213ca933 | 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... |
ea01947cae9447c0a665e2123388358741305d854929584ed3257e06f681a6a3 | """This tests sympy/core/basic.py with (ideally) no reference to subclasses
of Basic or Atom."""
import collections
import sys
from sympy.core.basic import (Basic, Atom, preorder_traversal, as_Basic,
_atomic, _aresame)
from sympy.core.singleton import S
from sympy.core.symbol import symbols, Symbol, Dummy
from sy... |
a2bc0448076aed3b560b9596c3a41f97f546afec8ba2c39b99e0e60c9c098fa3 | from sympy.abc import x, y
from sympy.core.parameters import evaluate
from sympy.core import Mul, Add, Pow, S
from sympy import sqrt, oo
def test_add():
with evaluate(False):
p = oo - oo
assert isinstance(p, Add) and p.args == (oo, -oo)
p = 5 - oo
assert isinstance(p, Add) and p.arg... |
45ea77ead581b3f62f43781a4594575702f74c8af6ba808a1db49501a00efe09 | from sympy.core import (
Basic, Rational, Symbol, S, Float, Integer, Mul, Number, Pow,
Expr, I, nan, pi, symbols, oo, zoo, N)
from sympy.core.tests.test_evalf import NS
from sympy.core.function import expand_multinomial
from sympy.functions.elementary.miscellaneous import sqrt, cbrt
from sympy.functions.element... |
8f6c120b9a84cc0e45c27768031cd029d4f2f660f3b14fce36aebe3310d0650d | 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... |
3dc70e940359f8aec71e93b531a572ff405909afaf5c80c782438cb9ccb0235d | from sympy import (abc, Add, cos, collect, Derivative, diff, exp, Float, Function,
I, Integer, log, Mul, oo, Poly, Rational, S, sin, sqrt, Symbol, symbols,
Wild, pi, meijerg, Sum
)
from sympy.testing.pytest import XFAIL
def test_symbol():
x = Symbol('x')
a, b, c, p, q = map(Wild, 'abcpq')
e = x
... |
7a7586e2b7fe40167199f77b24b404415ebd57b21b6e27216555aebff9dd7817 | 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... |
37a7860943a0eb4d366f5662e5ac4e23122ac4452c2add1de4322e1963bbc12d | """Tests that the IPython printing module is properly loaded. """
from sympy.interactive.session import init_ipython_session
from sympy.external import import_module
from sympy.testing.pytest import raises
# run_cell was added in IPython 0.11
ipython = import_module("IPython", min_module_version="0.11")
# disable te... |
8d6f125b0531912b5d457690b218e49d73886ebbfaba8be46049f2848b9ccf4e | """Domains of Gaussian type."""
from sympy.core.basic import Basic
from sympy.core.numbers import I
from sympy.polys.polyerrors import CoercionFailed
from sympy.polys.domains import ZZ, QQ
from sympy.polys.domains.domainelement import DomainElement
from sympy.polys.domains.field import Field
from sympy.polys.domains.r... |
0f0042697b84511743b9acedd00d3971412b74b3b2bf48ef07069a67c4566aba | """Tests for algorithms for partial fraction decomposition of rational
functions. """
from sympy.polys.partfrac import (
apart_undetermined_coeffs,
apart,
apart_list, assemble_partfrac_list
)
from sympy import (S, Poly, E, pi, I, Matrix, Eq, RootSum, Lambda,
Symbol, Dummy, factor, toget... |
4f14166cd9fe036da7a71ccf9d165e11f7610f14517b2aef948c967f748962fb | """Tests for user-friendly public interface to polynomial functions. """
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, invert,
subre... |
ab2ee12462b99cda9a9777267fcc89799279a23e2ed33d54f2192df837e414a4 | """Tests for classes defining properties of ground domains, e.g. ZZ, QQ, ZZ[x] ... """
from sympy import S, sqrt, sin, oo, Poly, Float, Rational, pi
from sympy.abc import x, y, z
from sympy.polys.domains import ZZ, QQ, RR, CC, FF, GF, EX
from sympy.polys.domains.realfield import RealField
from sympy.polys.domains.gau... |
4f98aff5b15130d2bbbaabfafd8780b3b81275f0457abab997c99ccb163fb92a | from sympy.testing.pytest import raises, XFAIL
from sympy.external import import_module
from sympy import (
Symbol, Mul, Add, Eq, Abs, sin, asin, cos, Pow,
csc, sec, Limit, oo, Derivative, Integral, factorial,
sqrt, root, StrictLessThan, LessThan, StrictGreaterThan,
GreaterThan, Sum, Product, E, log, t... |
b0413b94ecffeeccfda9de88c7443bdb4ff3e331fdec37bcd5128f49a87daf2e | # 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 .errors import LaTeXParsingError
LaTeXParser = LaTeXLexer = MathErrorListener = None
try:
LaTeXP... |
8a9bd4cced9e26c7ea7cab939987a41e0ef9a32dea0f6558eba6aacf0b887578 |
# encoding: utf-8
# *** GENERATED BY `setup.py antlr`, DO NOT EDIT BY HAND ***
#
# Generated from ../LaTeX.g4, derived from latex2sympy
# latex2sympy is licensed under the MIT license
# https://github.com/augustt198/latex2sympy/blob/master/LICENSE.txt
#
# Generated with antlr4
# antlr4 is licensed under th... |
2730760ebcf83a399b55f450991d96d537454af15e6e081d73dc28162d9fcd9e |
# encoding: utf-8
# *** GENERATED BY `setup.py antlr`, DO NOT EDIT BY HAND ***
#
# Generated from ../LaTeX.g4, derived from latex2sympy
# latex2sympy is licensed under the MIT license
# https://github.com/augustt198/latex2sympy/blob/master/LICENSE.txt
#
# Generated with antlr4
# antlr4 is licensed under th... |
159d491a31059d71f325b8ec0325284b59ec0bca5d32ff9c41c1d7d1eaf78036 | from __future__ import print_function, division
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__ = [
# ... |
ea364dbd7b6ff6e44181542b9c32069b2f0d8f483850f09380b51b3fb369284e | """Abstract tensor product."""
from __future__ import print_function, division
from sympy import Expr, Add, Mul, Matrix, Pow, sympify
from sympy.core.trace import Tr
from sympy.printing.pretty.stringpict import prettyForm
from sympy.physics.quantum.qexpr import QuantumError
from sympy.physics.quantum.dagger import D... |
6416fa0d5d77c5ee9141e3e6a3196d1f7594b40e4ee1fb5d404269442e734a40 | """The anti-commutator: ``{A,B} = A*B + B*A``."""
from __future__ import print_function, division
from sympy import S, Expr, Mul, Integer
from sympy.printing.pretty.stringpict import prettyForm
from sympy.physics.quantum.operator import Operator
from sympy.physics.quantum.dagger import Dagger
__all__ = [
'AntiC... |
41c1f7c304159fb38a21807f38694b1184b5e7122421772ded9b416f367645a0 | """Dirac notation for states."""
from __future__ import print_function, division
from sympy import (cacheit, conjugate, Expr, Function, integrate, oo, sqrt,
Tuple)
from sympy.printing.pretty.stringpict import stringPict
from sympy.physics.quantum.qexpr import QExpr, dispatch_method
__all__ = [
... |
449df2a047594fd3cc7d554a4bd9fbc99961899c2a15d93d17918842d2f58547 | """Logic for representing operators in state in various bases.
TODO:
* Get represent working with continuous hilbert spaces.
* Document default basis functionality.
"""
from __future__ import print_function, division
from sympy import Add, Expr, I, integrate, Mul, Pow
from sympy.physics.quantum.dagger import Dagger... |
8c2a8c1ab3b4184a33fbd104bfb6a0beab40eaeafd2f956f324d635628eae2ea | """Quantum mechanical operators.
TODO:
* Fix early 0 in apply_operators.
* Debug and test apply_operators.
* Get cse working with classes in this file.
* Doctests and documentation of special methods for InnerProduct, Commutator,
AntiCommutator, represent, apply_operators.
"""
from __future__ import print_function... |
e97f127696adfdc678c456ceb84880ae6100fce35d415b641904eb34cc04b772 | """Qubits for quantum computing.
Todo:
* Finish implementing measurement logic. This should include POVM.
* Update docstrings.
* Update tests.
"""
from __future__ import print_function, division
import math
from sympy import Integer, log, Mul, Add, Pow, conjugate
from sympy.core.basic import sympify
from sympy.core... |
f0a671b76147cd2bf97f6daf9373eeb7610d2985cd1c2caa62058aaede5be097 | """Symbolic inner product."""
from __future__ import print_function, division
from sympy import Expr, conjugate
from sympy.printing.pretty.stringpict import prettyForm
from sympy.physics.quantum.dagger import Dagger
from sympy.physics.quantum.state import KetBase, BraBase
__all__ = [
'InnerProduct'
]
# InnerPr... |
c7210da9a8334c7bedd114b80918811f42ce1537340afcc5f6c3e44c8027c268 | from __future__ import print_function, division
from itertools import product
from sympy import Tuple, Add, Mul, Matrix, log, expand, S
from sympy.core.trace import Tr
from sympy.printing.pretty.stringpict import prettyForm
from sympy.physics.quantum.dagger import Dagger
from sympy.physics.quantum.operator import Her... |
ba630478598e6b06fa530a17e8cee0e02a5c53b004a70840c22b2473df650c53 | """The commutator: [A,B] = A*B - B*A."""
from __future__ import print_function, division
from sympy import S, Expr, Mul, Add, Pow
from sympy.printing.pretty.stringpict import prettyForm
from sympy.physics.quantum.dagger import Dagger
from sympy.physics.quantum.operator import Operator
__all__ = [
'Commutator'
... |
91bfd75f89507429bc9e32bfd93165ee267a088db2fcddc5a553333cbb689633 | #TODO:
# -Implement Clebsch-Gordan symmetries
# -Improve simplification method
# -Implement new simpifications
"""Clebsch-Gordon Coefficients."""
from __future__ import print_function, division
from sympy import (Add, expand, Eq, Expr, Mul, Piecewise, Pow, sqrt, Sum,
symbols, sympify, Wild)
from sy... |
620fb6942cf019bac6fec9636faccc5cab00c175073eebdbea2cb3078ada42c3 | """Primitive circuit operations on quantum circuits."""
from __future__ import print_function, division
from sympy import Symbol, Tuple, Mul, sympify, default_sort_key
from sympy.utilities import numbered_symbols
from sympy.core.compatibility import reduce
from sympy.physics.quantum.gate import Gate
__all__ = [
... |
bbc065e626ae41a8c2573bcac1415a2f85f0312337f6ea3e91418ac64cc5cc6e | """Hilbert spaces for quantum mechanics.
Authors:
* Brian Granger
* Matt Curry
"""
from __future__ import print_function, division
from sympy import Basic, Interval, oo, sympify
from sympy.printing.pretty.stringpict import prettyForm
from sympy.physics.quantum.qexpr import QuantumError
from sympy.core.compatibilit... |
6e94f66df4d52bff22dd137787b233188a863f7bddbfd55737a3d2470bfef459 | from __future__ import print_function, division
from sympy.core.backend import sympify
from sympy.physics.vector import Point, ReferenceFrame, Dyadic
from sympy.utilities.exceptions import SymPyDeprecationWarning
__all__ = ['RigidBody']
class RigidBody(object):
"""An idealized rigid body.
This is essenti... |
53ea695ce5621f4d60d0b70566d8019643521d88935ae1301cc5b88cdffd00d1 | from __future__ import print_function, division
from sympy.core.backend import diff, zeros, Matrix, eye, sympify
from sympy.physics.vector import dynamicsymbols, ReferenceFrame
from sympy.physics.mechanics.functions import (find_dynamicsymbols, msubs,
_f_list_parser)
from... |
f5df2d45ad681f1b4951351535849a53b25e51b8c90a6d109f6332a6090184a6 | """
Module defining unit prefixe class and some constants.
Constant dict for SI and binary prefixes are defined as PREFIXES and
BIN_PREFIXES.
"""
from sympy import Expr, sympify
class Prefix(Expr):
"""
This class represent prefixes, with their name, symbol and factor.
Prefixes are used to create derived... |
23dfe680711ae7c884997dac0c1b7c13bd238c6d0a77eee55996c9c8b26dce9f | """
Several methods to simplify expressions involving unit objects.
"""
from __future__ import division
from sympy import Add, Mul, Pow, Tuple, sympify
from sympy.core.compatibility import reduce, Iterable, ordered
from sympy.physics.units.dimensions import Dimension
from sympy.physics.units.prefixes import Prefix
fr... |
084e5a8a5cc509e19cc1c36efd3fde4b2453d33ab4c6a4bfb262d00727252e65 | from sympy.core.backend import (S, sympify, expand, sqrt, Add, zeros,
ImmutableMatrix as Matrix)
from sympy import trigsimp
from sympy.core.compatibility import unicode
from sympy.utilities.misc import filldedent
__all__ = ['Vector']
class Vector(object):
"""The class used to define vectors.
It along wi... |
f1400a214170f4e8e2f8fe5d0267f90ddfacbd750ccf982adf236c77dd01e85d | from __future__ import print_function, division
from .vector import Vector, _check_vector
from .frame import _check_frame
__all__ = ['Point']
class Point(object):
"""This object represents a point in a dynamic system.
It stores the: position, velocity, and acceleration of a point.
The position is a vect... |
1aa3a406e00d86885acadd9a5468e2eb996681a84c72e0b38117d7db0df5433e | 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__ = ['CoordinateSym'... |
cd5ab3364c9a4445cae97404fbb19136e25425d45210845f29b986bea1fe9535 | """
This module can be used to solve 2D beam bending problems with
singularity functions in mechanics.
"""
from __future__ import print_function, division
from sympy.core import S, Symbol, diff, symbols
from sympy.solvers import linsolve
from sympy.printing import sstr
from sympy.functions import SingularityFunction,... |
41ec6dbaefc956c47ed55f638e7f3e6f354c23c5f4419679f9dc0ab5e5a65f0a | #!/usr/bin/env python
# -*- coding: utf-8 -*-
u"""
The module implements routines to model the polarization of optical fields
and can be used to calculate the effects of polarization optical elements on
the fields.
- Jones vectors.
- Stokes vectors.
- Jones matrices.
- Mueller matrices.
Examples
--------
We calcul... |
5c1b89ca90cb33c0dc1b93ec653a17d9892e4edd9f6e607ccfbce3aa4934bbb1 | """
**Contains**
* refraction_angle
* fresnel_coefficients
* deviation
* brewster_angle
* critical_angle
* lens_makers_formula
* mirror_formula
* lens_formula
* hyperfocal_distance
* transverse_magnification
"""
from __future__ import division
__all__ = ['refraction_angle',
'deviation',
'fresne... |
a596c7cc6e474fca6ebd01ca4c0ba0ed56548c9003cc373e22a5c37b7dfda4d6 | import sympy
from sympy.testing.pytest import warns_deprecated_sympy
def test_deprecated_imports():
# https://github.com/sympy/sympy/pull/18245
# Before 1.6 these names were importable with e.g.
# from sympy import *
# from sympy import add
# Now sympy/__init__.py uses __all__ so these names are no... |
c081c616b18fb047695c1c9141c3fc74de2e5c89434e158410eb9f7b5dec73cc | """Implementation of DPLL algorithm
Further improvements: eliminate calls to pl_true, implement branching rules,
efficient unit propagation.
References:
- https://en.wikipedia.org/wiki/DPLL_algorithm
- https://www.researchgate.net/publication/242384772_Implementations_of_the_DPLL_Algorithm
"""
from sympy import ... |
25313b97df2e9a82fed202d4919656b7ae82fd249b227a98b32fc1f1b113056c | from sympy import (
Rational, Symbol, N, I, Abs, sqrt, exp, Float, sin,
cos, symbols)
from sympy.matrices import eye, Matrix
from sympy.core.singleton import S
from sympy.testing.pytest import raises, XFAIL
from sympy.matrices.matrices import NonSquareMatrixError, MatrixError
from sympy.simplify.simplify import... |
4bf4ecb19100533ac1d8501507ec50791b127048a64d6800b2559763f40fd3cb | from sympy.assumptions import Q
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 import Abs
from sympy.functions.e... |
5b83b07e663e9a48c3654844f6b220d9d4bf3179c9557b3bf0a3b9deddf51ca7 | 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... |
48e364c529404756eb7bbfe227ca2c7efac25cbc2b3f9206584d810036c06caf | from sympy import Basic, Expr, S, sympify
from sympy.matrices.common import NonSquareMatrixError
class Determinant(Expr):
"""Matrix Determinant
Represents the determinant of a matrix expression.
Examples
========
>>> from sympy import MatrixSymbol, Determinant, eye
>>> A = MatrixSymbol('A',... |
aa4f1b662f9f0861ab6ed938acf2374e5347188804efd5b2eec4655372dbe9b0 | """ A module which handles Matrix Expressions """
from .slice import MatrixSlice
from .blockmatrix import BlockMatrix, BlockDiagMatrix, block_collapse, blockcut
from .companion import CompanionMatrix
from .funcmatrix import FunctionMatrix
from .inverse import Inverse
from .matadd import MatAdd
from .matexpr import (Id... |
5e42bbc576b0428463ed7d6640074f77e11a31d40579c27675e93c748a79963d | from sympy import Number
from sympy.core import Mul, Basic, sympify, S
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.matrices import MatrixBase
fro... |
a2829489a2ba93eec925e10cb09aef67c644c245316b4c8765470c6a9686812f | from typing import Any, Callable
from sympy.core.logic import FuzzyBool
from functools import wraps, reduce
import collections
from sympy.core import S, Symbol, Tuple, Integer, Basic, Expr, Eq, Mul, Add
from sympy.core.decorators import call_highest_priority
from sympy.core.compatibility import SYMPY_INTS, default_so... |
95750945b8d047a7b599d1d0749c0d2095cc5bcd1798a6ce56a36f5178c1e7b5 | from sympy.core.singleton import S
from sympy.core.sympify import _sympify
from sympy.polys.polytools import Poly
from .matexpr import MatrixExpr
class CompanionMatrix(MatrixExpr):
"""A symbolic companion matrix of a polynomial.
Examples
========
>>> from sympy import Poly, Symbol, symbols
>>> ... |
a61792b42176791487dbf5523479676faa6f92b64c6be72085dfa803c06f6776 | 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
>>... |
f6af64692466a3f9a084c4f965592f8079a3c1b9db6c18d41d507c56ac4e43df | from sympy import ask, Q
from sympy.core import Basic, Add, Mul, S
from sympy.core.sympify import _sympify
from sympy.matrices.common import NonInvertibleMatrixError
from sympy.strategies import typed, exhaust, condition, do_one, unpack
from sympy.strategies.traverse import bottom_up
from sympy.utilities import sift
fr... |
aab179589ce6dc49f8ba3699e88caaf3a06a36f70a32987af61d5da130d60402 | from .matexpr import MatrixExpr
from sympy.core.function import FunctionClass, Lambda
from sympy.core.symbol import Dummy
from sympy.core.sympify import _sympify, sympify
from sympy.matrices import Matrix
from sympy.functions.elementary.complexes import re, im
class FunctionMatrix(MatrixExpr):
"""Represents a mat... |
39fd18a405968854e05720d4938f71d324872e824145f10094f237095d9ef92f | from sympy.core import symbols, Lambda
from sympy.functions import KroneckerDelta
from sympy.matrices import Matrix
from sympy.matrices.expressions import FunctionMatrix, MatrixExpr, Identity
from sympy.testing.pytest import raises, warns_deprecated_sympy
def test_funcmatrix_creation():
i, j, k = symbols('i j k')... |
86013c1099cd6e027776d975ca8962688bb46a8bdc019f813d6fd201935f667f | from sympy.core import S, symbols
from sympy.matrices import eye, Matrix, ShapeError
from sympy.matrices.expressions import (
Identity, MatrixExpr, MatrixSymbol, Determinant,
det, ZeroMatrix, Transpose
)
from sympy.matrices.expressions.matexpr import OneMatrix
from sympy.testing.pytest import raises
from sympy ... |
1732647d0a99bbcb0c946f3ce8da7606c499004032b6b2f72fc58560569ac697 | """
Some examples have been taken from:
http://www.math.uwaterloo.ca/~hwolkowi//matrixcookbook.pdf
"""
from sympy import (MatrixSymbol, Inverse, symbols, Determinant, Trace,
Derivative, sin, exp, cos, tan, log, S, sqrt,
hadamard_product, DiagMatrix, OneMatrix,
H... |
40f233c217e361a6243c298503728383e6c9ae2ce4763df59465ebee357a78fe | 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... |
cd7199b383a8d729185ba27c9de2b8ed98d4afaa10f426b468b3d856750e2121 | from sympy.core.expr import unchanged
from sympy.core.symbol import Symbol, symbols
from sympy.matrices.immutable import ImmutableDenseMatrix
from sympy.matrices.expressions.companion import CompanionMatrix
from sympy.polys.polytools import Poly
from sympy.testing.pytest import raises
def test_creation():
x = Sym... |
4cadc590e530c762cfd7fc4da9022e694f7a6c431fc1c593328162d5ed20a8db | from sympy.sets.setexpr import SetExpr
from sympy.sets import Interval, FiniteSet, Intersection, ImageSet, Union
from sympy import (Expr, Set, exp, log, cos, Symbol, Min, Max, S, oo, I,
symbols, Lambda, Dummy, Rational)
a, x = symbols("a, x")
_d = Dummy("d")
def test_setexpr():
se = SetExpr(Interval(0,... |
ecc397d453e8235abaf8581f8f13cc8d8b3938a3e77db66d8bc7a96ae9de20c5 | 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 ... |
391165c9a1333d2ce77fc97254780bc0395d2e2b697cb9f3c376c7039358f08f | 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, ... |
0ccec651141b7527dc75d1f3db733139285ab4115cdbab4ffec7771bca460901 | """Plotting module that can plot 2D and 3D functions
"""
from sympy.utilities.decorator import doctest_depends_on
@doctest_depends_on(modules=('pyglet',))
def PygletPlot(*args, **kwargs):
"""
Plot Examples
=============
See examples/advanced/pyglet_plotting.py for many more examples.
>>> from s... |
3d73f226e23a171de81304f2153d18a557b42be0c5925398b677afd76286fc08 | from __future__ import print_function, division
from threading import RLock
# it is sufficient to import "pyglet" here once
try:
import pyglet.gl as pgl
except ImportError:
raise ImportError("pyglet is required for plotting.\n "
"visit http://www.pyglet.org/")
from sympy.core.compatibil... |
5701fe0649f24384cbfc683c1ac82c1265012bf38c64c9b759037b753726591d | #!/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 ... |
79b927ca209d2b3bd9b4f3ac6dc7c6dc76139963a5563bba46d827ff73bb4992 | """
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... |
11ea83913d7b97476fadf1cedc82fd0936e9173c82b11ed51863c082b4c8e97e | #!/usr/bin/env python
"""FEM library
Demonstrates some simple finite element definitions, and computes a mass
matrix
$ python fem.py
[ 1/60, 0, -1/360, 0, -1/90, -1/360]
[ 0, 4/45, 0, 2/45, 2/45, -1/90]
[-1/360, 0, 1/60, -1/90, 0, -1/360]
[ 0, 2/45, -1/90, 4/45, 2/45, 0]
... |
a87475b69f38fe22975a421497fc4a6e33e68cd37dd18511397184747dbea475 | from __future__ import print_function, division
import random
from sympy import (Matrix, MatrixSymbol, S, Indexed, Basic,
Set, And, Eq, FiniteSet, ImmutableMatrix,
Lambda, Mul, Dummy, IndexedBase, Add,
linsolve, eye, Or, Not, Intersection,
Uni... |
5e910313b236dfecef1cae89b2508df345df8ac39ec993daacbe53be807fb667 | """
SymPy statistics module
Introduces a random variable type into the SymPy language.
Random variables may be declared using prebuilt functions such as
Normal, Exponential, Coin, Die, etc... or built with functions like FiniteRV.
Queries on random expressions can be made using the functions
======================... |
3501c3ba719d8487c862bd6a46aa0ba893ea5ffea380896c8e74d26d69e2f87c | import itertools
from sympy import (MatrixExpr, Expr, ShapeError, ZeroMatrix,
Add, Mul, MatMul, S, expand as _expand)
from sympy.stats.rv import RandomSymbol, is_random
from sympy.core.sympify import _sympify
from sympy.stats.symbolic_probability import Variance, Covariance, Expectation
class Expe... |
96b0e6ffc2bd85abdaff2f186c6b5860ddf40d1333c039f61c194d61635a68a6 | from __future__ import print_function, division
from sympy.sets import FiniteSet
from sympy import sqrt, log, exp, FallingFactorial, Rational, Eq, Dummy, piecewise_fold, solveset
from .rv import (probability, expectation, density, where, given, pspace, cdf, PSpace,
characteristic_function, sample, samp... |
43e60d480dadf261d460b504487d47c01a82433a8dba7acbafaa927a46277852 | """
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 __future__ import print_function... |
6c50fdefce25b0dbc76ef770bf87e75355cda96c9a544baa099a467b5fd69d09 | import itertools
from sympy import Expr, Add, Mul, S, Integral, Eq, Sum, Symbol, expand as _expand
from sympy.core.compatibility import default_sort_key
from sympy.core.parameters import global_parameters
from sympy.core.sympify import _sympify
from sympy.stats import variance, covariance
from sympy.stats.rv import (R... |
e90782ee4a9a94415734eff208cc5a8558a05779921972edaaa9026348190e7b | """
Number theory module (primes, etc)
"""
from .generate import nextprime, prevprime, prime, primepi, primerange, \
randprime, Sieve, sieve, primorial, cycle_length, composite, compositepi
from .primetest import isprime, is_gaussian_prime
from .factor_ import divisors, proper_divisors, factorint, multiplicity, \
... |
967a926dfa45e6515ed2702020bf31c2c9ee0e058cbd70ea7d95889e6492ef4e | from sympy.ntheory import sieve, isprime
from sympy.core.power import integer_log
from sympy.core.compatibility import as_int
import random
#----------------------------------------------------------------------------#
# #
# L... |
05a38b5f9acfec05975d1323bd376c81d292a94368d9966d681d4bf05ecd0924 | from __future__ import print_function, division
from sympy.core import S, Symbol, Add, sympify, Expr, PoleError, Mul
from sympy.core.exprtools import factor_terms
from sympy.core.symbol import Dummy
from sympy.functions.combinatorial.factorials import factorial
from sympy.functions.special.gamma_functions import gamma... |
2a14d9034e56b4eb09d3564fbfff42d45c5abc3666637dc78136d023e84da165 | """Limits of sequences"""
from __future__ import print_function, division
from sympy.core.add import Add
from sympy.core.function import PoleError
from sympy.core.power import Pow
from sympy.core.singleton import S
from sympy.core.symbol import Dummy
from sympy.core.sympify import sympify
from sympy.functions.combina... |
ad24839459dae19841c5c586eb057e2da93f3e52c7d97b2e55891e0da745596f | """Fourier Series"""
from __future__ import print_function, division
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 ... |
de685393562a26e102a3699003dd9130aebaf5b9426bd2413f213bbe2cad8f3e | """Formal Power Series"""
from __future__ import print_function, division
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 ... |
999d2b7a6a24442b46293484706fd50547d305374a65c20e9c176075db79b95d | from __future__ import print_function, division
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 sy... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.