hash stringlengths 64 64 | content stringlengths 0 1.51M |
|---|---|
6790d63968b464fad71236882045fdc6e4d001e6e6004a7c098bfe7302c8364e | 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... |
081663f7a69384b24b21a53ab04ebbd6a8257c3afb5c17334ef81808e838919a | from sympy import (Symbol, exp, Integer, Float, sin, cos, 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)
from sy... |
014ceea8580bac5da598a94753dc1df8718d760b28e72c6807f62977c7e67fd5 | 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
... |
c0f3bc981a4c3ca574b2f955d99a22f776c6f860bc64777f374361845d31daa7 | 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... |
80bad982e87aa44d04e3fbccd8678e4b96c79eb7125105ea0f4433f6d22d7e6a | from sympy.polys.rings import ring
from sympy.polys.fields import field
from sympy.polys.domains import ZZ, QQ
from sympy.polys.solvers import solve_lin_sys
# Expected times on 3.4 GHz i7:
# In [1]: %timeit time_solve_lin_sys_189x49()
# 1 loops, best of 3: 864 ms per loop
# In [2]: %timeit time_solve_lin_sys_165x165(... |
442b423dee329aa39c1597d10950326b9c347faaa459aee8ef7bd04b556b979c | """Implementation of mathematical domains. """
__all__ = [
'Domain', 'FiniteField', 'IntegerRing', 'RationalField', 'RealField',
'ComplexField', 'AlgebraicField', 'PolynomialRing', 'FractionField',
'ExpressionDomain', 'PythonRational',
'GF', 'FF', 'ZZ', 'QQ', 'ZZ_I', 'QQ_I', 'RR', 'CC', 'EX', 'EXRAW',... |
ca82f5bd319bf19b3ce2fd1023e84f6e0ce262ad0fdb228a286560541cc4e6a9 | """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... |
428374494c522a9587ee3abb93ac9a60b0634bd182306e80dcef9802466d575d | """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... |
de8c08b2fe012a66570727faa9a69d3599f816f6661b4d52dadff17a1f7fdf2d | '''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... |
63d6dd9d5c521735816db66501264f7ed31819658796a4e06b5693fe8354a432 | """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, exp, E
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, EXRAW, ZZ_g... |
df81abd55346c437ba9fe3dee299328dca649404896cf58b94a2e726bbb79a7a | from sympy.external import import_module
lfortran = import_module('lfortran')
if lfortran:
from sympy.codegen.ast import (Variable, IntBaseType, FloatBaseType, String,
Return, FunctionDefinition, Assignment)
from sympy.core import Add, Mul, Integer, Float
from sympy impo... |
09bcef4d0224d5f530b923e1e4839de37c3b50c6c54586bab7570e899782f18f | """Abstract tensor product."""
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 Dagger
from sympy.physics.quantum.commutator impor... |
bc294508166887cfd7aba27e6010d934137f27b78c725f9605436a00ea28fffc | """Dirac notation for states."""
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__ = [
'KetBase',
'BraBase',
'StateBase',
'... |
130563b4fa0d0e42e57186e9c44296d9e2b9be0c87bf72f6de9035798d12a4f9 | """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 sympy import Derivative, Expr, I... |
5a3a28304182113b31038da7a00a7fa6a204da8e96c238898d74ea9d86541de2 | """Quantum mechanical angular momemtum."""
from sympy import (Add, binomial, cos, exp, Expr, factorial, I, Integer, Mul,
pi, Rational, S, sin, simplify, sqrt, Sum, symbols, sympify,
Tuple, Dummy)
from sympy.matrices import zeros
from sympy.printing.pretty.stringpict import prettyF... |
7f7996ab4277b174fa62284e7cb3ebda559984dff1500fd5a27a8d519abc8c37 | #TODO:
# -Implement Clebsch-Gordan symmetries
# -Improve simplification method
# -Implement new simpifications
"""Clebsch-Gordon Coefficients."""
from sympy import (Add, expand, Eq, Expr, Mul, Piecewise, Pow, sqrt, Sum,
symbols, sympify, Wild)
from sympy.printing.pretty.stringpict import prettyForm,... |
35e7119d5105d25ae638cd2a46e099adff6a0c16ff05657f4f2b889bd252fa43 | """Fermionic quantum operators."""
from sympy import Integer
from sympy.physics.quantum import Operator
from sympy.physics.quantum import HilbertSpace, Ket, Bra
from sympy.functions.special.tensor_functions import KroneckerDelta
__all__ = [
'FermionOp',
'FermionFockKet',
'FermionFockBra'
]
class Fermio... |
e1ba57c727e3ba085f68d75a5f94c77a609fba7e1ab50b8366df4cd96bb73374 | """Pauli operators and states"""
from sympy import I, Mul, Add, Pow, exp, Integer
from sympy.physics.quantum import Operator, Ket, Bra
from sympy.physics.quantum import ComplexSpace
from sympy.matrices import Matrix
from sympy.functions.special.tensor_functions import KroneckerDelta
__all__ = [
'SigmaX', 'SigmaY'... |
9d0773cad8491e10a5e532e00568027da0481704654a9dbb0154e30bf371287d | """Logic for applying operators to states.
Todo:
* Sometimes the final result needs to be expanded, we should do this by hand.
"""
from sympy import Add, Mul, Pow, sympify, S
from sympy.physics.quantum.anticommutator import AntiCommutator
from sympy.physics.quantum.commutator import Commutator
from sympy.physics.qua... |
bb8cb87f10b5021edfffcdc4428df0ca9d06fc9940b57d7cd30e7638fe139ffe | """
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... |
2e6bf3d08bced4c6547bd89756af6557082946136a2db28853019dc4e7331093 | from sympy import Derivative
from sympy.core.function import UndefinedFunction, AppliedUndef
from sympy.core.symbol import Symbol
from sympy.interactive.printing import init_printing
from sympy.printing.latex import LatexPrinter
from sympy.printing.pretty.pretty import PrettyPrinter
from sympy.printing.pretty.pretty_sy... |
8f0158a78df6ef37e87379614012dc12a0a82eebc189a75e924037629c7061c1 | from sympy.core.backend import (S, sympify, expand, sqrt, Add, zeros, acos,
ImmutableMatrix as Matrix, _simplify_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']
c... |
387c143375cc0106f5f8d0538bbe68e865690fc23653d82f406fdcc6cbee4af2 | from sympy.physics.secondquant import (
Dagger, Bd, VarBosonicBasis, BBra, B, BKet, FixedBosonicBasis,
matrix_rep, apply_operators, InnerProduct, Commutator, KroneckerDelta,
AnnihilateBoson, CreateBoson, BosonicOperator,
F, Fd, FKet, BosonState, CreateFermion, AnnihilateFermion,
evaluate_deltas, Ant... |
6e4cafd7e0ea57b8ab8374f5d0a63aaf9489b08b0b80a3c50d91a6e2066d04a1 | """
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... |
c306faba38315d153a41cf4432bf71e45f13cb763087dd00f2d1eff157c39d4e | from sympy import sin, cos, Matrix, sqrt, pi, expand_mul, S
from sympy.core.backend import _simplify_matrix
from sympy.core.symbol import symbols
from sympy.physics.mechanics import dynamicsymbols, Body, PinJoint, PrismaticJoint
from sympy.physics.mechanics.joint import Joint
from sympy.physics.vector import Vector, Re... |
be4875cad072b79c3ff7bef7bd60b3a873a2fc6366fb98e3c86ef70196ff8fa7 | from sympy.physics.mechanics import (dynamicsymbols, ReferenceFrame, Point,
RigidBody, LagrangesMethod, Particle,
inertia, Lagrangian)
from sympy import symbols, pi, sin, cos, tan, simplify, Function, \
Derivative, Matrix
def test_disc_on... |
c7b9e7b096abd9f1cb94640827b2bcd1977a37d0b81f3f6c1fc7afe1369365a5 | from sympy.core.backend import (symbols, Matrix, cos, sin, atan, sqrt,
Rational, _simplify_matrix)
from sympy import solve, simplify, sympify
from sympy.physics.mechanics import dynamicsymbols, ReferenceFrame, Point,\
dot, cross, inertia, KanesMethod, Particle, RigidBody, Lagrangian,\
LagrangesMethod
from s... |
66a67965ffa12db11029d3afe0ad60dc67b4e20c2b68911fddb500384f3b4af3 | """
MKS unit system.
MKS stands for "meter, kilogram, second, ampere".
"""
from typing import List
from sympy.physics.units.definitions import Z0, A, C, F, H, S, T, V, Wb, ohm
from sympy.physics.units.definitions.dimension_definitions import (
capacitance, charge, conductance, current, impedance, inductance,
... |
279d592c51217d302e08e9e0480d21f81623597c0f79f02df4141837caeab70a | from sympy import expand, Symbol, symbols, S, Interval, pi, Rational, simplify
from sympy.physics.continuum_mechanics.beam import Beam
from sympy.functions import SingularityFunction, Piecewise, meijerg, Abs, log
from sympy.testing.pytest import raises
from sympy.physics.units import meter, newton, kilo, giga, milli
fr... |
2016d3985ab2c4a9a2034ef074e7c9e1def890bf536b8312b2900d2d187d3db6 | 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... |
63218e9df021d37c3d54c6d44e4c556877d3c5bf30451ceb73bec3ff1f8964f7 | from sympy import S, Dict, Basic, Tuple
from sympy.core.sympify import _sympify
from sympy.tensor.array.mutable_ndim_array import MutableNDimArray
from sympy.tensor.array.ndim_array import NDimArray, ImmutableNDimArray
import functools
class SparseNDimArray(NDimArray):
def __new__(self, *args, **kwargs):
... |
5aace3174bc8523660e7bfb018caa39377eae40687b03425295387ac289a1961 | from sympy import Basic
from sympy import S
from sympy.core.expr import Expr
from sympy.core.numbers import Integer
from sympy.core.sympify import sympify
from sympy.core.kind import Kind, NumberKind, UndefinedKind
from sympy.core.compatibility import SYMPY_INTS
from sympy.printing.defaults import Printable
import ite... |
cb487744c572b830db1a55efa403280b0d381a436d96bd16114a060ac810cafe | import functools
from sympy import Basic, Tuple, S
from sympy.core.sympify import _sympify
from sympy.tensor.array.mutable_ndim_array import MutableNDimArray
from sympy.tensor.array.ndim_array import NDimArray, ImmutableNDimArray
from sympy.simplify.simplify import simplify
class DenseNDimArray(NDimArray):
def ... |
ded8fd4363af39fc564ae40b5cf0cf6f38a71b3f940c9579b0800d726a6b52fa | import itertools
from collections import defaultdict, Counter
from typing import Tuple, Union, FrozenSet, Dict, List, Optional
from functools import singledispatch
from itertools import accumulate
from sympy import Trace, MatrixExpr, Transpose, DiagMatrix, Mul, ZeroMatrix, hadamard_product, S, Identity, ask, Q
from sy... |
28f3765982105ca2814858a8e02ee33b88f852027aaa366ddcb3080acaeb8ab5 | import operator
from functools import reduce
import itertools
from itertools import accumulate
from typing import Optional, List, Dict
import typing
from sympy import Expr, ImmutableDenseNDimArray, S, Symbol, ZeroMatrix, Basic, tensorproduct, Add, permutedims, \
Tuple, tensordiagonal, Lambda, Dummy, Function, Mat... |
f812c7251b5594ab2d46824b960f53e3e6c6cecdccb6861c970459a5daa27688 | from sympy import (
symbols, Identity, cos, ZeroMatrix, OneMatrix, sqrt, HadamardProduct)
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, conve... |
9764ef195754b867a2ff8f6a7c5eb977a73e29fde6d72c2b604b14d043978814 | 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, ... |
09962a18597c09e58288a33819da3f3a819d55d5797cb7ff73bb542e82c1f434 | 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.tri... |
f0f979b13a848028cc5d0a9641fe146ca47743c423dee543495c82308f21814b | 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.matrices.expressions.fou... |
a96959169a08a9f35d613ab662bc428815c18ce8765c763c3d66524ea91fc17c | 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, nan, oo, pi, signsimp, simplify, sin,
sqrt, symbols, sympify, trigsimp, tan, sstr, diff, Function, expand, Fini... |
ba718b51d9704195c7f906f04f3a4c8c78cd462294e966841167c80f530abb95 | 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',... |
539cede71b6e0922ff046f5eaddaa4b7a73dc14b4b5004ce903963059cb4886c | 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.... |
e44865684612423d0188eb17de7e46d9a23e06b61df2d62457b336b778cb0e3d | 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... |
c17e1702bc4263a1c5f9fe5e1a2f00401993878fac0fe81b1cbc14b13597e2c5 | from functools import reduce
import operator
from sympy.core import Add, Basic, sympify
from sympy.core.add import add
from sympy.functions import adjoint
from sympy.matrices.common import ShapeError
from sympy.matrices.matrices import MatrixBase
from sympy.matrices.expressions.transpose import transpose
from sympy.st... |
07e4a8a5d607134a5116252c07ddf8d64231c38978792bd6f4268b69c652bdcc | 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... |
816e2fda6363ad52edf3d4f287fb2dcf79db17a8d893812299ceeb057ad3d35d | 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... |
f80ea4ac2a8e49bfe4d16b2698f8fa9b05d45bdacf91b7d8e57a4f8c01d3fc69 |
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... |
3bbf9a2a938bc27a51869d3a4d19a4e43e3267434c3b026be7f025cbd267b825 | import pyglet.gl as pgl
from pyglet import font
from sympy.core import S
from sympy.core.compatibility import is_sequence
from sympy.plotting.pygletplot.plot_object import PlotObject
from sympy.plotting.pygletplot.util import billboard_matrix, dot_product, \
get_direction_vectors, strided_range, vec_mag, vec_s... |
01428ba6ffdb64648692fc5e8827ee07da74c07cef6eb78b13522fed4698773b | #!/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... |
96a84d89e3e4883cc741d7fec14ab988578253f9a40d693c6d93602291cf3628 | # -*- coding: utf-8 -*-
from __future__ import print_function, division, absolute_import
import os
from itertools import chain
import json
import sys
import warnings
import pytest
from sympy.testing.runtests import setup_pprint, _get_doctest_blacklist
durations_path = os.path.join(os.path.dirname(__file__), '.ci', '... |
29cd2bacc4d3a2b05b5b980b49c6c2146ac4d34e0cdb591cf82902b3f6a5ce47 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
A tool to generate AUTHORS. We started tracking authors before moving
to git, so we have to do some manual rearrangement of the git history
authors in order to get the order in AUTHORS. bin/mailmap_update.py
should be run before committing the results.
"""
from __futur... |
872d58a8c4d9fa144c32069e19e446efc9d67ba4dc964cbef1f6f8cd216e441b | #!/usr/bin/env python
"""
Program to test that all methods/functions have at least one example
doctest. Also checks if docstrings are imported into Sphinx. For this to
work, the Sphinx docs need to be built first. Use "cd doc; make html" to
build the Sphinx docs.
Usage:
./bin/coverage_doctest.py sympy/core
or
./... |
79263b4658933e62730d1e35ffb0c80ec3f057c09d33fd36b29bc4e58034640c | #!/usr/bin/env python
"""
A tool to help keep .mailmap up-to-date with the
current git authors.
See also bin/authors_update.py
"""
import codecs
import sys
import os
if sys.version_info < (3, 7):
sys.exit("This script requires Python 3.7 or newer")
from subprocess import run, PIPE
from sympy.external.importtoo... |
eb99e6c8ccd7643c07a1bfb382fede243a3ecead12bfdf09a3998a88e43c1b3e | # -*- coding: utf-8 -*-
"""
Fab file for releasing
Please read the README in this directory.
Guide for this file
===================
Vagrant is a tool that gives us a reproducible VM, and fabric is a tool that
we use to run commands on that VM.
Each function in this file should be run as
fab vagrant func
Even tho... |
5668f1e0fb5b8126a329d38e43a821b0103c2d3d80c5b92d9d1ab48687639246 | #!/usr/bin/env python3
from pathlib import Path
from tempfile import TemporaryDirectory
from subprocess import check_call
PY_VERSIONS = '3.7', '3.8', '3.9'
def main(version, outdir):
for pyversion in PY_VERSIONS:
test_sdist(pyversion, version, outdir)
test_wheel(pyversion, version, outdir)
d... |
71489e54191e7ea932f571d84bb717f8f7679a4b7469f6b58fb73f6a99a96697 | """
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... |
def83e1a50f0f18f0c1a86b7db81684494771da45a2616698977534d5a0d0282 | import sys
sys._running_pytest = True # type: ignore
from sympy.external.importtools import version_tuple
import pytest
from sympy.core.cache import clear_cache, USE_CACHE
from sympy.external.gmpy import GROUND_TYPES, HAS_GMPY
from sympy.utilities.misc import ARCH
import re
sp = re.compile(r'([0-9]+)/([1-9][0-9]*)')... |
168c627cdd5882cdcb247c6388e707bf4ebfa370362f38c16deec306d06651e5 | """
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``,... |
4d11d87c2ec20c98d852c3aa27a14d032dd83b65c08b78a950e6a68558cc54c8 | #!/usr/bin/env python
"""Pi digits example
Example shows arbitrary precision using mpmath with the
computation of the digits of pi.
"""
from mpmath import libmp, pi
import math
import sys
from time import perf_counter
def display_fraction(digits, *, skip=0, colwidth=10, columns=5):
"""Pretty printer for first... |
637e2df2ed05d2273a6e79e7272ac664ad3cde1027431a381b073a9f14401cdd | #!/usr/bin/env python
"""
Plotting Examples
Suggested Usage: python -i pyglet_plotting.py
"""
from sympy import symbols, sin, cos, pi, sqrt
from sympy.plotting.pygletplot import PygletPlot
from time import sleep, perf_counter
def main():
x, y, z = symbols('x,y,z')
# toggle axes visibility with F5, co... |
2eb85c69487de362a4c0aa9aa4022bb503467facd3c8db90662279f72aac7b5f | #
# SymPy documentation build configuration file, created by
# sphinx-quickstart.py on Sat Mar 22 19:34:32 2008.
#
# This file is execfile()d with the current directory set to its containing dir.
#
# The contents of this file are pickled, so don't put values in the namespace
# that aren't pickleable (module imports are... |
c3d4982e536b1d0c7e8ab95af00c4677b760e1993f86362e31d6b5310a85286e | """
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... |
268e2119c2889e66ec91f0599e9c032e8ce102ac3e03ff45c947f091f20dc45d | """
Finite Discrete Random Variables - Prebuilt variable types
Contains
========
FiniteRV
DiscreteUniform
Die
Bernoulli
Coin
Binomial
BetaBinomial
Hypergeometric
Rademacher
IdealSoliton
RobustSoliton
"""
from sympy.core.cache import cacheit
from sympy.core.function import Lambda
from sympy.core.numbers import (Integ... |
29bce7b5462c69e265a5d78ccc14a2bb619221869638c3992da74fb75b2d5da2 | 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, Set as tSet)
from sympy.concrete.summations import Sum
from sympy.core.add import Add
from sympy.core.basic import Basic
from sympy.core.ca... |
bd606d6c6b52e57b5f47f17be4052c7ccab88e3bafaca2f2531ad12f49d84c36 | from sympy.core.basic import Basic
from sympy.core.mul import prod
from sympy.core.numbers import pi
from sympy.core.singleton import S
from sympy.functions.elementary.exponential import exp
from sympy.functions.special.gamma_functions import multigamma
from sympy.core.sympify import sympify, _sympify
from sympy.matric... |
4c97979bb0541dca3fca48bf1b6b7ff5aae7924ca947f891e2aac218d4ab7b53 | """
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
======================... |
188e8a15416438948299bc7ca098f36a55703b8d86b31d08a28f4297df5010df | from sympy.concrete.products import Product
from sympy.concrete.summations import Sum
from sympy.core.add import Add
from sympy.core.function import Lambda
from sympy.core.mul import Mul
from sympy.core.numbers import (Integer, Rational, pi)
from sympy.core.power import Pow
from sympy.core.relational import Eq
from sym... |
efc444328a900893584376dc5c779773f6f4cfb443e186a0a2bf85f8543671a2 | from sympy.core.basic import Basic
from sympy.stats.rv import PSpace, _symbol_converter, RandomMatrixSymbol
class RandomMatrixPSpace(PSpace):
"""
Represents probability space for
random matrices. It contains the mechanics
for handling the API calls for random matrices.
"""
def __new__(cls, sym,... |
1d117391d1ed8f60b870552e89e751b0aeb0f42be90b9525475589bb02331138 | import itertools
from sympy.core.add import Add
from sympy.core.expr import Expr
from sympy.core.function import expand as _expand
from sympy.core.mul import Mul
from sympy.core.singleton import S
from sympy.matrices.common import ShapeError
from sympy.matrices.expressions.matexpr import MatrixExpr
from sympy.matrices... |
6be1fa19912276c88fff8fa2370ee7483f7d00cc8de83347b12974214646200b | """Tools for arithmetic error propagation."""
from itertools import repeat, combinations
from sympy.core.add import Add
from sympy.core.mul import Mul
from sympy.core.power import Pow
from sympy.core.singleton import S
from sympy.core.symbol import Symbol
from sympy.functions.elementary.exponential import exp
from sy... |
cfd7feffb94f7582451aeed3ecc374447b5717d340417e224435e2ddf31d25cf | """
Contains
========
FlorySchulz
Geometric
Hermite
Logarithmic
NegativeBinomial
Poisson
Skellam
YuleSimon
Zeta
"""
from sympy.concrete.summations import Sum
from sympy.core.basic import Basic
from sympy.core.function import Lambda
from sympy.core.numbers import I
from sympy.core.relational import Eq
from sympy.cor... |
dc4be4076b923be2297f679bb372b099ef4067b6c680f60e6ff1f3fe1f4d6c9b | from sympy.sets import FiniteSet
from sympy.core.numbers import Rational
from sympy.core.relational import Eq
from sympy.core.symbol import Dummy
from sympy.functions.combinatorial.factorials import FallingFactorial
from sympy.functions.elementary.exponential import (exp, log)
from sympy.functions.elementary.miscellane... |
7ee2bafaa0dbe364a2f39e1faa9cbb4d7d3ec8c7af36249da70bbc59a274665a | """
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... |
ca59a10a457699e1ddcc04803d5a168f02fa345b14966a97babe8df6bea08510 | """
Joint Random Variables Module
See Also
========
sympy.stats.rv
sympy.stats.frv
sympy.stats.crv
sympy.stats.drv
"""
from sympy.core.basic import Basic
from sympy.core.function import Lambda
from sympy.core.mul import prod
from sympy.core.singleton import S
from sympy.core.symbol import (Dummy, Symbol)
from sympy.... |
7b0c589d4942caf685e5c78ca738a2cf87ba1408249f33f9702d5956f43f60b1 | from sympy.concrete.summations import (Sum, summation)
from sympy.core.basic import Basic
from sympy.core.cache import cacheit
from sympy.core.function import Lambda
from sympy.core.numbers import I
from sympy.core.relational import (Eq, Ne)
from sympy.core.singleton import S
from sympy.core.symbol import (Dummy, symbo... |
54aee3bd88901f9db76abe90bcbcd5fe4ebbbb4821702aeb5a5060b7770c75ac | """
Continuous Random Variables Module
See Also
========
sympy.stats.crv_types
sympy.stats.rv
sympy.stats.frv
"""
from sympy.core.basic import Basic
from sympy.core.cache import cacheit
from sympy.core.function import Lambda, PoleError
from sympy.core.numbers import (I, nan, oo)
from sympy.core.relational import (Eq... |
b9123e1debe381c725c1f51bd26338ab1a39935208618878bd21db00c3450f76 | from sympy.concrete.summations import Sum
from sympy.core.basic import Basic
from sympy.core.function import Lambda
from sympy.core.symbol import Dummy
from sympy.integrals.integrals import Integral
from sympy.stats.rv import (NamedArgsMixin, random_symbols, _symbol_converter,
PSpace, RandomSymb... |
90c36b2052c0676a3eeb5e148a09bb41c6b67760f5c2870ba9a9e38c4ced67cd | import itertools
from sympy.concrete.summations import Sum
from sympy.core.add import Add
from sympy.core.expr import Expr
from sympy.core.function import expand as _expand
from sympy.core.mul import Mul
from sympy.core.relational import Eq
from sympy.core.singleton import S
from sympy.core.symbol import Symbol
from s... |
a3b0497f413a0c506bad21f3130c47586f27963ddbd8af2b68899d17cc550cb0 | from sympy.concrete.products import Product
from sympy.concrete.summations import Sum
from sympy.core.basic import Basic
from sympy.core.function import Lambda
from sympy.core.numbers import (I, pi)
from sympy.core.singleton import S
from sympy.core.symbol import Dummy
from sympy.functions.elementary.complexes import A... |
0b8147015b9c9317559d71a5993f79ec0b79c5d38b558bc7efa2a02f8e13477f | """
Finite Discrete Random Variables Module
See Also
========
sympy.stats.frv_types
sympy.stats.rv
sympy.stats.crv
"""
from itertools import product
from sympy.concrete.summations import Sum
from sympy.core.basic import Basic
from sympy.core.cache import cacheit
from sympy.core.function import Lambda
from sympy.core.... |
a43cf4adb2974e268d98c9a6cfbd1d3f717f2962ff5e1a022851d804db7541e5 | from sympy.core.basic import Basic
from sympy.stats.joint_rv import ProductPSpace
from sympy.stats.rv import ProductDomain, _symbol_converter, Distribution
class StochasticPSpace(ProductPSpace):
"""
Represents probability space of stochastic processes
and their random variables. Contains mechanics to do
... |
413ba42297f1defd575edce38eaf92cc92069865ef928448d0b6fda61eea01cc | #!/usr/bin/env python
from random import random
from sympy.core.numbers import (I, Integer, pi)
from sympy.core.symbol import Symbol
from sympy.core.sympify import sympify
from sympy.functions.elementary.miscellaneous import sqrt
from sympy.functions.elementary.trigonometric import sin
from sympy.polys.polytools import... |
94689aced43546c2ce024557d1db6ef8cc37c6019cd00b29987a19dec2007a0a | # conceal the implicit import from the code quality tester
from sympy.core.numbers import (oo, pi)
from sympy.core.symbol import (Symbol, symbols)
from sympy.functions.elementary.exponential import exp
from sympy.functions.elementary.miscellaneous import sqrt
from sympy.functions.special.bessel import besseli
from symp... |
527bc7491e93b64e1393330969a1d2a52318189e887322479b1440af1e3dad84 | from sympy.core.numbers import oo
from sympy.core.relational import Eq
from sympy.core.symbol import symbols
from sympy.polys.domains import FiniteField, QQ, RationalField, FF
from sympy.solvers.solvers import solve
from sympy.utilities.iterables import is_sequence
from sympy.utilities.misc import as_int
from .factor_ ... |
dc57fe8a1c848aab88a8355479413b1b2003def71b66b9a077f0cfbb37ef4de5 | '''
This implementation is a heavily modified fixed point implementation of
BBP_formula for calculating the nth position of pi. The original hosted
at: http://en.literateprograms.org/Pi_with_the_BBP_formula_(Python)
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and a... |
3f8c7591b1957436f825b09d8b120179ce75d895f421fadf3393b123bdd01157 | """
Generating and counting primes.
"""
import random
from bisect import bisect
from itertools import count
# Using arrays for sieving instead of lists greatly reduces
# memory consumption
from array import array as _array
from sympy.core.function import Function
from sympy.core.singleton import S
from .primetest im... |
d630fd1c9fac41792224c30f784be8c71ef7b059764a3d856fbf3ea53afc4378 | from sympy.ntheory import sieve, isprime
from sympy.core.numbers import mod_inverse
from sympy.core.power import integer_log
from sympy.utilities.misc import as_int
import random
rgen = random.Random()
#----------------------------------------------------------------------------#
# ... |
6ca89bca1e9799c561fefe76ea2c214823df60cde48705e0fafacf6b8c50ba9f | from sympy.core.function import Function
from sympy.core.numbers import igcd, igcdex, mod_inverse
from sympy.core.power import isqrt
from sympy.core.singleton import S
from sympy.polys.domains import ZZ
from .primetest import isprime
from .factor_ import factorint, trailing, totient, multiplicity
from sympy.utilities.m... |
c45ce8332002dfa7cb4793afb537ada17512be13536cfdc7298fdca3c45412be | from collections import defaultdict
from sympy.utilities.iterables import multiset, is_palindromic as _palindromic
from sympy.utilities.misc import as_int
def digits(n, b=10, digits=None):
"""
Return a list of the digits of ``n`` in base ``b``. The first
element in the list is ``b`` (or ``-b`` if ``n`` i... |
45491be562fec714929c9112b3bf2bb527dc47bb90f96d2d11aa6d00af63dab4 | from functools import reduce
from sympy.core.mul import prod
from sympy.core.numbers import igcdex, igcd
from sympy.ntheory.primetest import isprime
from sympy.polys.domains import ZZ
from sympy.polys.galoistools import gf_crt, gf_crt1, gf_crt2
from sympy.utilities.misc import as_int
def symmetric_residue(a, m):
... |
adb9b74938e07d16cd55b70f787ebdaad5a4b6d8520a4d2c0b7ef736e0cce9f5 | from sympy.utilities.misc import as_int
def binomial_coefficients(n):
"""Return a dictionary containing pairs :math:`{(k1,k2) : C_kn}` where
:math:`C_kn` are binomial coefficients and :math:`n=k1+k2`.
Examples
========
>>> from sympy.ntheory import binomial_coefficients
>>> binomial_coeffici... |
ee0f63d594280f6d92469473028f20d449c341ad7af8353e06ff6785be063fa9 | """
Primality testing
"""
from sympy.core.numbers import igcd
from sympy.core.power import integer_nthroot
from sympy.core.sympify import sympify
from sympy.external.gmpy import HAS_GMPY
from sympy.utilities.misc import as_int
from mpmath.libmp import bitcount as _bitlength
def _int_tuple(*i):
return tuple(int... |
a71265dabdabad6c74ab4e0e141bc4b3f0316242ab59ae80cd6b220e65571af5 | from sympy.core.containers import Tuple
from sympy.core.numbers import (Integer, Rational)
from sympy.core.singleton import S
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 ration... |
8516c7162818ed85b72c0c84e71cde9b65a069fdee92489f13fba9f502e87925 | from sympy.core.numbers import Integer, Rational
from sympy.core.singleton import S
from sympy.core.sympify import _sympify
from sympy.utilities.misc import as_int
def continued_fraction(a):
"""Return the continued fraction representation of a Rational or
quadratic irrational.
Examples
========
... |
bf037041b818bf9502f7b7f058eec512f86a2c82ef4779c68e16972cbedc5a0e | from sympy.core.numbers import igcd, mod_inverse
from sympy.core.power import integer_nthroot
from sympy.ntheory.residue_ntheory import _sqrt_mod_prime_power
from sympy.ntheory import isprime
from math import log, sqrt
import random
rgen = random.Random()
class SievePolynomial:
def __init__(self, modified_coeff=(... |
491aa72af194f0baac5319273f948d8f25cd0c48fde60c8755fdd019a562a1ee | """
Integer factorization
"""
from collections import defaultdict
import random
import math
from sympy.core import sympify
from sympy.core.containers import Dict
from sympy.core.evalf import bitcount
from sympy.core.expr import Expr
from sympy.core.function import Function
from sympy.core.logic import fuzzy_and
from ... |
280d26e8e6e7bb3efe763536d00215f4d108989f097558a3d88fe65905dc02ba | from sympy.combinatorics import Permutation
from sympy.combinatorics.util import _distribute_gens_by_base
rmul = Permutation.rmul
def _cmp_perm_lists(first, second):
"""
Compare two lists of permutations as sets.
Explanation
===========
This is used for testing purposes. Since the array form of... |
c7453a6200e901c57ad4d8fbe872ee927a45758308f4557269b6b6bf010876d4 | from random import randrange, choice
from math import log
from sympy.ntheory import primefactors
from sympy.core.symbol import Symbol
from sympy.ntheory.factor_ import (factorint, multiplicity)
from sympy.combinatorics import Permutation
from sympy.combinatorics.permutations import (_af_commutes_with, _af_invert,
... |
982bde9ca324119d38478ba24692565b382b14fbac9b2d184fdb835691fbbb77 | from sympy.core import Basic
import random
class GrayCode(Basic):
"""
A Gray code is essentially a Hamiltonian walk on
a n-dimensional cube with edge length of one.
The vertices of the cube are represented by vectors
whose values are binary. The Hamilton walk visits
each vertex exactly once. ... |
4fc290533b01b3f9c9d9172f8809b51e84bb4acaed8f5efbe35da6ec2867a38c | import random
from collections import defaultdict
from collections.abc import Iterable
from functools import reduce
from sympy.core.parameters import global_parameters
from sympy.core.basic import Atom
from sympy.core.expr import Expr
from sympy.core.numbers import Integer
from sympy.core.sympify import _sympify
from ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.