hash stringlengths 64 64 | content stringlengths 0 1.51M |
|---|---|
7579784458f71a883c766a0e218294959fb9448aa4924ca2e315bb777afc093f | from sympy import Identity, OneMatrix, ZeroMatrix, Matrix, MatAdd
from sympy.core import symbols
from sympy.testing.pytest import raises
from sympy.matrices import ShapeError, MatrixSymbol
from sympy.matrices.expressions import (HadamardProduct, hadamard_product, HadamardPower, hadamard_power)
n, m, k = symbols('n,m,... |
165cc7ef438177131644b1b6e26f0fa83e442f25746c0538d63d82a5e90391ce | from sympy import Set, symbols, exp, log, S, Wild, Dummy, oo
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,
... |
118b21757039b40196a256835fe9c7028969ef12093783aa6f551cd42d488492 | from sympy.core.symbol import symbols, Symbol
from sympy.functions import Max
from sympy.plotting.experimental_lambdify import experimental_lambdify
from sympy.plotting.intervalmath.interval_arithmetic import \
interval, intervalMembership
# Tests for exception handling in experimental_lambdify
def test_experimen... |
2720a0e6e85ed195377b137f3ba74c181439e32d4dbd3030777c992dcb0a8b93 | 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 ... |
8a3b66dc7a20eee6431f252ca2a2682910b789b13f5992a6ae5ba01267023b79 | from __future__ import print_function, division
from pyglet.window import Window
from pyglet.clock import Clock
from threading import Thread, Lock
gl_lock = Lock()
class ManagedWindow(Window):
"""
A pyglet window with an event loop which executes automatically
in a separate thread. Behavior is added by... |
2f1b703cbb54a8856ef440c5e507827d8ff998a6bc73624377c1227d3dd5c6ac | #!/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... |
0eb3371ef8938aeb1c72b57ce6638ac5da05a954377b0fd417ca0903634bc4f6 | #!/usr/bin/env python3
import subprocess
import sys
from os.path import join, splitext, basename
from contextlib import contextmanager
from tempfile import TemporaryDirectory
from zipfile import ZipFile
from shutil import copytree
def main(sympy_doc_git, doc_html_zip, version, push=None):
"""Run this as ./updat... |
e5bd292ebdc26518304b5d470095aa51c9e16571b0bc5911fe3c277cd130ce52 | #!/usr/bin/env python3
from subprocess import check_output
import sys
import os.path
def main(tarname, gitroot):
"""Run this as ./compare_tar_against_git.py TARFILE GITROOT
Args
====
TARFILE: Path to the built sdist (sympy-xx.tar.gz)
GITROOT: Path ro root of git (dir containing .git)
"""
... |
b3abc8f088f0d8f82a97179acc3c362f3006e85bf25e1c029c404f8838d6445b | """
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... |
ed24c80894f4859652c48db991d272ac4701a69498dcc7bd57e8c9438feade6a | """
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
Logistic
Lo... |
24c16b3f96b85231c8210241c1b33e39c444f5b4dbb8678277282f1355ca6614 | """
Finite Discrete Random Variables - Prebuilt variable types
Contains
========
FiniteRV
DiscreteUniform
Die
Bernoulli
Coin
Binomial
BetaBinomial
Hypergeometric
Rademacher
"""
from __future__ import print_function, division
from sympy import (S, sympify, Rational, binomial, cacheit, Integer,
Dumm... |
77bc092443f055b13fd771af879b25fe4ee538430e339a32f59324c40b997d7e | from __future__ import print_function, division
from sympy import (Matrix, MatrixSymbol, S, Indexed, Basic,
Set, And, Eq, FiniteSet, ImmutableMatrix,
Lambda, Mul, Dummy, IndexedBase, Add,
linsolve, eye, Or, Not, Intersection,
Union, Expr, Func... |
5333e0844d6621ff1961645dbb79bc875b787f8c1118d19c1be49edd39f2aea2 | from sympy import (sympify, S, pi, sqrt, exp, Lambda, Indexed, besselk, gamma, Interval,
Range, factorial, Mul, Integer,
Add, rf, Eq, Piecewise, ones, Symbol, Pow, Rational, Sum,
Intersection, Matrix, symbols, Product, IndexedBase)
from sympy.matrices import Immu... |
a4e99a15edbd5ee9d0f512258eb700c1da553f9db48556d9860a71a5341c380b | """Tools for arithmetic error propagation."""
from __future__ import print_function, division
from itertools import repeat, combinations
from sympy import S, Symbol, Add, Mul, simplify, Pow, exp
from sympy.stats.symbolic_probability import RandomSymbol, Variance, Covariance
from sympy.stats.rv import is_random
_arg0... |
3c2f1eae393099d89e4752f90bcd4d22a4b3ec9c2f188d2ae701c3ed4699c612 | """
Contains
========
Geometric
Hermite
Logarithmic
NegativeBinomial
Poisson
Skellam
YuleSimon
Zeta
"""
from __future__ import print_function, division
from sympy import (Basic, factorial, exp, S, sympify, I, zeta, polylog, log, beta,
hyper, binomial, Piecewise, floor, besseli, sqrt, Sum, Dummy,
... |
d4086c855697e9086decb33705ea558cfcbf9bb98ebd0582b25744a5a77fdf7c | 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... |
9c1ef5d80c38b28f5924df92438e75ec46544b5ae4f7304ce0ec59131f8f5502 | """
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... |
25548866438f79a04ec3f417c2f614b199f742a34aab297cd8957f43257969a2 | from __future__ import print_function, division
from sympy import (Basic, sympify, symbols, Dummy, Lambda, summation,
Piecewise, S, cacheit, Sum, exp, I, Ne, Eq, poly,
series, factorial, And, lambdify)
from sympy.polys.polyerrors import PolynomialError
from sympy.stats.crv import... |
e468a71a10c223a0c5967399c406e88d5c0879a666bc48e8220d85099cb87540 | """
Continuous Random Variables Module
See Also
========
sympy.stats.crv_types
sympy.stats.rv
sympy.stats.frv
"""
from __future__ import print_function, division
from sympy import (Interval, Intersection, symbols, sympify, Dummy, nan,
Integral, And, Or, Piecewise, cacheit, integrate, oo, Lambda,
Basi... |
c29ea459f8247a269ea8dacc427bf44fc1e577c99179cf5ee49d9566d4a28b92 | 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... |
36eecf38b30d61814ba7e2e3a2106e18369ae6a82e06bb58f4f8c46b2312d4f5 | from __future__ import print_function, division
from sympy import (Basic, exp, pi, Lambda, Trace, S, MatrixSymbol, Integral,
gamma, Product, Dummy, Sum, Abs, IndexedBase, I)
from sympy.core.sympify import _sympify
from sympy.stats.rv import _symbol_converter, Density, RandomMatrixSymbol, is_random
f... |
e3d9f34e49abd144c661cb183af684a62ac54f4d500c75427d199e935584708b | """
Finite Discrete Random Variables Module
See Also
========
sympy.stats.frv_types
sympy.stats.rv
sympy.stats.crv
"""
from __future__ import print_function, division
from itertools import product
from sympy import (Basic, Symbol, cacheit, sympify, Mul,
And, Or, Piecewise, Eq, Lambda, exp, I, Dummy... |
1b815c53f851400cc58737ae1ac17b524fbfd6641acd270881ee2bc61be9e5f6 | from sympy.core.compatibility import as_int, is_sequence
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 .factor_ import divisors
from .residue_nth... |
10edb06c49744f00928ccdd9e3856b4876a4b43fbd490f2b339afd80ea09def5 | """
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 import Function, S
from sympy.core.compatibility import as_int
from .primetest impo... |
366fcabe859b248e734e95ecc1c544fa43b3e1e8126c117330414b6cbf8be917 | from sympy.core.compatibility import as_int
from sympy.core.function import Function
from sympy.utilities.iterables import cartes
from sympy.core.numbers import igcd, igcdex, mod_inverse
from sympy.core.power import isqrt
from sympy.core.singleton import S
from .primetest import isprime
from .factor_ import factorint, ... |
6c2050c6853942b5db63bc415b39e9dade5e5b4bfc0a33144edbd9ffab7970c9 | from collections import defaultdict
from sympy.core.compatibility import as_int
from sympy.utilities.iterables import multiset, is_palindromic as _palindromic
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... |
c1e3189ba824ebd9d402389d5479268b3ccc112164b00a89517f8ef8b12feeeb | from sympy.core.compatibility import as_int, 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
def symmetric_residue(a, m):
"""Return the res... |
7a5f7176e9bb78cfd990d4298e7b537bb16ccd88ad1e0eb3957ca5ec8e94d07d | from sympy.core.numbers import Integer, Rational
from sympy.core.singleton import S
from sympy.core.sympify import _sympify
def continued_fraction(a):
"""Return the continued fraction representation of a Rational or
quadratic irrational.
Examples
========
>>> from sympy.ntheory.continued_fractio... |
1a122f7de0f0674bf11e1627fcbc15479bdb31759d3668f06eada371e2015c26 | """
Integer factorization
"""
from collections import defaultdict
import random
import math
from sympy.core import sympify
from sympy.core.compatibility import as_int, SYMPY_INTS
from sympy.core.containers import Dict
from sympy.core.evalf import bitcount
from sympy.core.expr import Expr
from sympy.core.function impo... |
ab9eed7e770a56403d98158d87ee20e92cc494094b3739c68fa09c25d8c2c711 | 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.
This is used for testing purposes. Since the array form of a
permutation is currently a... |
81c582d56a6bd77ee9da7685f0e410e5c1850ba3cd6b27969a20e0ab7914f431 | from random import randrange, choice
from math import log
from sympy.ntheory import primefactors
from sympy import multiplicity, factorint, Symbol
from sympy.combinatorics import Permutation
from sympy.combinatorics.permutations import (_af_commutes_with, _af_invert,
_af_rmul, _af_rmuln, _af_pow, Cycle)
from sympy... |
de3933f6498a219248ae64987c550618e5e8cf202596d61a68988acf80457c70 | from sympy.combinatorics.permutations import Permutation
from sympy.core.symbol import symbols
from sympy.matrices import Matrix
from sympy.utilities.iterables import variations, rotate_left
def symmetric(n):
"""
Generates the symmetric group of order n, Sn.
Examples
========
>>> from sympy.comb... |
471ae43c22ee6c097f8775dc132d3fc7c2d6a633b4b5a285ea28065d4e766aa8 | import random
from collections import defaultdict
from sympy.core.parameters import global_parameters
from sympy.core.basic import Atom
from sympy.core.expr import Expr
from sympy.core.compatibility import \
is_sequence, reduce, as_int, Iterable
from sympy.core.numbers import Integer
from sympy.core.sympify import... |
db68d39edb730a8305715b9dcc8429b089e3c5d8481487c29b1d230a7f4a394b | from typing import Dict, List
from sympy.core import S
from sympy.core.compatibility import is_sequence, as_int
from sympy.core.expr import Expr
from sympy.core.symbol import Symbol, symbols as _symbols
from sympy.core.sympify import CantSympify
from sympy.printing.defaults import DefaultPrinting
from sympy.utilities ... |
92dd0ce7dab2af638dd5d7780b0b3aae4d01eede20352b49cc101dc8606163f7 | from sympy.combinatorics.permutations import Permutation, _af_rmul, \
_af_invert, _af_new
from sympy.combinatorics.perm_groups import PermutationGroup, _orbit, \
_orbit_transversal
from sympy.combinatorics.util import _distribute_gens_by_base, \
_orbits_transversals_from_bsgs
"""
References for tensor ... |
0d72a224468b16c0e54722222db148fa2b5d947cfd4c3e17aa3a1eaed717d022 | from sympy.combinatorics import Permutation as Perm
from sympy.combinatorics.perm_groups import PermutationGroup
from sympy.core import Basic, Tuple
from sympy.core.compatibility import as_int
from sympy.sets import FiniteSet
from sympy.utilities.iterables import (minlex, unflatten, flatten)
rmul = Perm.rmul
class P... |
a89eeb13ab86f7acd08a7d80bffcad8ce536a89a7695455710622731398cffc3 | import itertools
from sympy.combinatorics.fp_groups import FpGroup, FpSubgroup, simplify_presentation
from sympy.combinatorics.free_groups import FreeGroup
from sympy.combinatorics.perm_groups import PermutationGroup
from sympy.core.numbers import igcd
from sympy.ntheory.factor_ import totient
from sympy import S
clas... |
bd7012995ee5bc1b08b1dd9946327a6b7153a30a139d9b7ba55cde77361d7a46 | from sympy.combinatorics.permutations import Permutation, _af_invert, _af_rmul
from sympy.ntheory import isprime
rmul = Permutation.rmul
_af_new = Permutation._af_new
############################################
#
# Utilities for computational group theory
#
############################################
def _base_or... |
82ce40275064738a6b65de3a15172605c9635f48a595e88d42cceae466ae5b8c | from sympy.combinatorics.free_groups import free_group
from sympy.printing.defaults import DefaultPrinting
from itertools import chain, product
from bisect import bisect_left
###############################################################################
# COSET TABLE ... |
62264e40e7bc15b12d7d4a66559c7bf5f4d76a9996dcfdd565f14e7757e5273d | from sympy.combinatorics.group_constructs import DirectProduct
from sympy.combinatorics.perm_groups import PermutationGroup
from sympy.combinatorics.permutations import Permutation
_af_new = Permutation._af_new
def AbelianGroup(*cyclic_orders):
"""
Returns the direct product of cyclic groups with the given o... |
c233ebfc26b725edba3fbe7fd9051e4795a32fcaad8b2f49d10516ba784665e0 | """Finitely Presented Groups and its algorithms. """
from sympy import S
from sympy.combinatorics.free_groups import (FreeGroup, FreeGroupElement,
free_group)
from sympy.combinatorics.rewritingsystem import RewritingSystem
from sympy.combinatorics.coset_table import (Cos... |
eff7ca4a90e81b7b61a4f7d52bd6397e0102f9f6c46180f0d683b4c34f1ba7e3 | from sympy.core.mul import Mul
from sympy.core.singleton import S
from sympy.concrete.expr_with_intlimits import ExprWithIntLimits
from sympy.core.exprtools import factor_terms
from sympy.functions.elementary.exponential import exp, log
from sympy.polys import quo, roots
from sympy.simplify import powsimp
class Produ... |
059f81f082063ff2348921262d2ba8ee681ca3d3795b4dfbeb70f218483be398 | """
This module implements sums and products containing the Kronecker Delta function.
References
==========
- http://mathworld.wolfram.com/KroneckerDelta.html
"""
from sympy.core import Add, Mul, S, Dummy
from sympy.core.cache import cacheit
from sympy.core.compatibility import default_sort_key
from sympy.functions ... |
16b7d20b5a14882c840be0a1f18547cc8904fea32d31a2320cf62dd4dd9159ab | """Gosper's algorithm for hypergeometric summation. """
from sympy.core import S, Dummy, symbols
from sympy.core.compatibility import is_sequence
from sympy.polys import Poly, parallel_poly_from_expr, factor
from sympy.solvers import solve
from sympy.simplify import hypersimp
def gosper_normal(f, g, n, polys=True):
... |
39559a4f547acaf92f20037e8c2695972f2b2d81890190f3e17ba0419e940579 | """Various algorithms for helping identifying numbers and sequences."""
from sympy.utilities import public
from sympy.core import Function, Symbol
from sympy.core.numbers import Zero
from sympy import (sympify, floor, lcm, denom, Integer, Rational,
exp, integrate, symbols, Product, product)
from sy... |
b193eee1e5ff88072b306477e5ff1b8d952c1f2b7fd9ef1aa81bb4247d97ec2b | from sympy.calculus.singularities import is_decreasing
from sympy.calculus.util import AccumulationBounds
from sympy.concrete.expr_with_limits import AddWithLimits
from sympy.concrete.expr_with_intlimits import ExprWithIntLimits
from sympy.concrete.gosper import gosper_sum
from sympy.core.add import Add
from sympy.core... |
9ac2f89e4df50a35eb0f8cfcc1aa92452f6ad0822262915b00c7811608a3de21 | from __future__ import print_function, division
from sympy.core.sympify import sympify
def series(expr, x=None, x0=0, n=6, dir="+"):
"""Series expansion of expr around point `x = x0`.
Parameters
==========
expr : Expression
The expression whose series is to be expanded.
x : Symbol
... |
23944efff925ab4600e4265e0781985379012d4e0b7bf5ec6ce396ad85c53bc3 | from __future__ import print_function, division
from sympy.core.basic import Basic
from sympy.core.cache import cacheit
from sympy.core.compatibility import is_sequence, iterable, ordered
from sympy.core.containers import Tuple
from sympy.core.decorators import call_highest_priority
from sympy.core.parameters import g... |
02c3cb2a09e4693b09e854df9ac9d423172defece3f6e33d77344f5b8a82b612 | 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... |
7ccd47a53e6748526e463095de560b69a41df942b431937d71c582785a2ce698 | """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 ... |
da3803ca622e204c021b4ff240813937377cc220d6d2de4635826bd10714dfa4 | """
This module implements the Residue function and related tools for working
with residues.
"""
from __future__ import print_function, division
from sympy import sympify
from sympy.utilities.timeutils import timethis
@timethis('residue')
def residue(expr, x, x0):
"""
Finds the residue of ``expr`` at the po... |
b0b471a04b0da30eeebc8ec9de181f49811fa5b92708e3b98d53425de9cb34ee | """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 ... |
0ca2a6c226f4987a87b7a1437c6c5bdc4083c31547fd390359f8ecc9f30cdbfb | from __future__ import print_function, division
def finite_diff(expression, variable, increment=1):
"""
Takes as input a polynomial expression and the variable used to construct
it and returns the difference between function's value when the input is
incremented to 1 and the original function value. I... |
b70d14bacde994fdab8c99987c030b7e75a4aafe3673dd06377965ce227123ae | """
Expand Hypergeometric (and Meijer G) functions into named
special functions.
The algorithm for doing this uses a collection of lookup tables of
hypergeometric functions, and various of their properties, to expand
many hypergeometric functions in terms of special functions.
It is based on the following paper:
... |
58a681e2ad70d7a915ba393be20538258e4da2f614099a1e54b051847868c369 | from __future__ import print_function, division
from collections import defaultdict
from sympy.core import (Basic, S, Add, Mul, Pow, Symbol, sympify,
expand_func, Function, Dummy, Expr, factor_terms,
expand_power_exp, Eq)
from sympy.core.compatibility import iterable, o... |
85fd330de3f723d4a3218591efcdb7faac5f1fe3c02547451d014ab5c796d943 | from __future__ import print_function, division
from collections import defaultdict
from sympy import SYMPY_DEBUG
from sympy.core import expand_power_base, sympify, Add, S, Mul, Derivative, Pow, symbols, expand_mul
from sympy.core.add import _unevaluated_Add
from sympy.core.compatibility import iterable, ordered, de... |
0c6f693112b944a65f21af7f78b1021525bfd25c3e3cc178e3144ac35ff26b7e | from __future__ import print_function, division
from collections import defaultdict
from sympy.core.function import expand_log, count_ops
from sympy.core import sympify, Basic, Dummy, S, Add, Mul, Pow, expand_mul, factor_terms
from sympy.core.compatibility import ordered, default_sort_key, reduce
from sympy.core.numb... |
51e8b218f59d67beff37fe5f742b3759927c8dcc04c355811757448b09102b59 | from __future__ import print_function, division
from sympy.core import Function, S, Mul, Pow, Add
from sympy.core.compatibility import ordered, default_sort_key
from sympy.core.function import count_ops, expand_func
from sympy.functions.combinatorial.factorials import binomial
from sympy.functions import gamma, sqrt, ... |
9086d62784aed5f37fb10561a4873d93d9b8f969bd172c5377df0d767e6645f8 | from __future__ import print_function, division
from collections import defaultdict
from sympy.core import (sympify, Basic, S, Expr, expand_mul, factor_terms,
Mul, Dummy, igcd, FunctionClass, Add, symbols, Wild, expand)
from sympy.core.cache import cacheit
from sympy.core.compatibility import reduce, iterable, SY... |
2774a34076edba07ac69133eb3e1919ae4051219eae215664332c274eb4021b9 | """
Implementation of the trigsimp algorithm by Fu et al.
The idea behind the ``fu`` algorithm is to use a sequence of rules, applied
in what is heuristically known to be a smart order, to select a simpler
expression that is equivalent to the input.
There are transform rules in which a single rule is applied to the
e... |
cd5b1cc2e151db9106e42495feecfef98655d06062264564cf2d9d2190ff1531 | from __future__ import print_function, division
from itertools import combinations_with_replacement
from sympy.core import symbols, Add, Dummy
from sympy.core.numbers import Rational
from sympy.polys import cancel, ComputationFailed, parallel_poly_from_expr, reduced, Poly
from sympy.polys.monomials import Monomial, mo... |
789ed8111daa8c87c228bffa57e0b6ee5f449cb90608d175deb8416968f3762f | from sympy.core import S, Basic, Dict, Symbol, Tuple, sympify
from sympy.core.compatibility import iterable
from sympy.sets import Set, FiniteSet, EmptySet
class Class(Set):
r"""
The base class for any kind of class in the set-theoretic sense.
In axiomatic set theories, everything is a class. A class wh... |
d9d6610173f5f95f6b2ca3e570d6091edb40903a3243bc317fd21f3172ab8435 | # References :
# http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/
# https://en.wikipedia.org/wiki/Quaternion
from sympy import S, Rational
from sympy import re, im, conjugate, sign
from sympy import sqrt, sin, cos, acos, exp, ln
from sympy import trigsimp
from sympy import integrate
from sympy... |
626151cfbc19ea68ea3ec9af34ec178a65d55e148fdcf7cc04b2c15dec7786d6 | from typing import Any, Set
from itertools import permutations
from sympy.combinatorics import Permutation
from sympy.core import (
Basic, Expr, Dummy, Function, diff,
Pow, Mul, Add, Atom
)
from sympy.core.compatibility import reduce
from sympy.core.numbers import Zero
from sympy.core.sympify import _sympify... |
1d25114995ea14dd45df5e7839d8690e63209b4a29a59f3e33a6c75b00983d82 | """
AST nodes specific to Fortran.
The functions defined in this module allows the user to express functions such as ``dsign``
as a SymPy function for symbolic manipulation.
"""
from sympy.codegen.ast import (
Attribute, CodeBlock, FunctionCall, Node, none, String,
Token, _mk_Tuple, Variable
)
from sympy.core... |
20755e0b41192d4a990e64f1a4342403c641b725abfe83bc5d09301633cd98b2 | import bisect
import itertools
from functools import reduce
from collections import defaultdict
from sympy import Indexed, IndexedBase, Tuple, Sum, Add, S, Integer, diagonalize_vector, DiagMatrix
from sympy.combinatorics import Permutation
from sympy.core.basic import Basic
from sympy.core.compatibility import accumul... |
0f8331e7acbe57846f665e0969bb2ddac1560433901fa7e4ffb1b10dd7426fd8 | """
Classes and functions useful for rewriting expressions for optimized code
generation. Some languages (or standards thereof), e.g. C99, offer specialized
math functions for better performance and/or precision.
Using the ``optimize`` function in this module, together with a collection of
rules (represented as instan... |
1ce08c08d7af2dfe96b7be1ba648d9e7ac3affba35b66cb798b78c94d926f9f7 | """
Types used to represent a full function/module as an Abstract Syntax Tree.
Most types are small, and are merely used as tokens in the AST. A tree diagram
has been included below to illustrate the relationships between the AST types.
AST Type Tree
-------------
::
*Basic*
|--->AssignmentBase
| ... |
e47e0fcdd54da71942302bf3799231090814e9e47228180328ec0f5f01c1e8bc | from typing import Dict, Callable
from sympy.core import S, Add, Expr, Basic, Mul
from sympy.logic.boolalg import Boolean
from sympy.assumptions import Q, ask # type: ignore
def refine(expr, assumptions=True):
"""
Simplify an expression using assumptions.
Gives the form of expr that would be obtained i... |
a5eece1695ff508bbd96502e143f1fc44a96c8adb0ad600fa1d345b0554b22fb | import inspect
from sympy.core.cache import cacheit
from sympy.core.singleton import S
from sympy.core.sympify import _sympify
from sympy.logic.boolalg import Boolean
from sympy.utilities.source import get_class
from contextlib import contextmanager
class AssumptionsContext(set):
"""Set representing assumptions.
... |
29e95dd4512f3d3aacc75f7595dc2761b221dd2505d465e74e6fc3f4114187fd | from __future__ import print_function, division
from sympy.core.add import Add
from sympy.core.compatibility import ordered
from sympy.core.function import expand_log
from sympy.core.power import Pow
from sympy.core.singleton import S
from sympy.core.symbol import Dummy
from sympy.functions.elementary.exponential impo... |
f5748bfea76b95efe862e808b4d3c6d056c51aa6bffae1f9065504b1e8d6a6e9 | """
This module contains functions to:
- solve a single equation for a single variable, in any domain either real or complex.
- solve a single transcendental equation for a single variable in any domain either real or complex.
(currently supports solving in real domain only)
- solve a system of lin... |
724556d894cc82084ea6fe98440c2d53f921ad91b64c3d9746af25601344cc89 | """
This module contains pdsolve() and different helper functions that it
uses. It is heavily inspired by the ode module and hence the basic
infrastructure remains the same.
**Functions in this module**
These are the user functions in this module:
- pdsolve() - Solves PDE's
- classify_pde() - Classif... |
ac3ec397e9e0f69ef9a2914751bb7b638a870605613b1c3ceab6ea136680d84a | """Utility functions for classifying and solving
ordinary and partial differential equations.
Contains
========
_preprocess
ode_order
_desolve
"""
from __future__ import print_function, division
from sympy.core import Pow
from sympy.core.function import Derivative, AppliedUndef
from sympy.core.relational import Equa... |
3e83c02c0423f0c06331ab60cc91b2ccecd4edfa8ab95700e5f6397704658c24 | """Tools for solving inequalities and systems of inequalities. """
from __future__ import print_function, division
from sympy.core import Symbol, Dummy, sympify
from sympy.core.compatibility import iterable
from sympy.core.exprtools import factor_terms
from sympy.core.relational import Relational, Eq, Ge, Lt
from sym... |
19bc4288fad06c526834e5fc7d2bf697a052dbb1fc39ab5c9c3c45029b399469 | """
This module contain solvers for all kinds of equations:
- algebraic or transcendental, use solve()
- recurrence, use rsolve()
- differential, use dsolve()
- nonlinear (numerically), use nsolve()
(you will need a good starting point)
"""
from __future__ import print_function, division
fr... |
ea3ab3d3b1445c1b7c882a5064054b4059d389002e0be423ce299389120b780c | """
Convolution (using **FFT**, **NTT**, **FWHT**), Subset Convolution,
Covering Product, Intersecting Product
"""
from sympy.core import S, sympify
from sympy.core.compatibility import as_int, iterable
from sympy.core.function import expand_mul
from sympy.discrete.transforms import (
fft, ifft, ntt, intt, fwht, i... |
da7dde2b510ba294802f8017909dedfab2d1f0f6231968a6d861737ff0791b6f | """
Finite difference weights
=========================
This module implements an algorithm for efficient generation of finite
difference weights for ordinary differentials of functions for
derivatives from 0 (interpolation) up to arbitrary order.
The core algorithm is provided in the finite difference weight generat... |
d86a239ddf4caae132b3523c8391e7a8c152dce3acba5e473e97227570b36f79 | from sympy import Order, S, log, limit, lcm_list, im, re, Dummy
from sympy.core import Add, Mul, Pow
from sympy.core.basic import Basic
from sympy.core.compatibility import iterable
from sympy.core.expr import AtomicExpr, Expr
from sympy.core.function import expand_mul
from sympy.core.numbers import _sympifyit, oo
from... |
5eb644dcf5a3c177c0a1ddb1201bb056a5c05418a8eb557ec7c4d4af7ddf4350 | """
This module provides convenient functions to transform sympy expressions to
lambda functions which can be used to calculate numerical values very fast.
"""
from typing import Any, Dict
import inspect
import keyword
import textwrap
import linecache
from sympy.core.compatibility import (exec_, is_sequence, iterabl... |
03a6a5a9fa97608930a34a65c41f5b14f56923d2e55416cf271177a44297cd75 | """Useful utility decorators. """
import sys
import types
import inspect
from sympy.core.decorators import wraps
from sympy.core.compatibility import get_function_globals, get_function_name, iterable
from sympy.testing.runtests import DependencyError, SymPyDocTests, PyTestReporter
def threaded_factory(func, use_add)... |
f14875058ea100c736fbaef6190acfdbb34c915e9a1f1c1bc70596f1414ed11a | from collections import defaultdict, OrderedDict
from itertools import (
combinations, combinations_with_replacement, permutations,
product, product as cartes
)
import random
from operator import gt
from sympy.core import Basic
# this is the logical location of these functions
from sympy.core.compatibility im... |
49f16f4fb1a36114d88df7a0f1d8f8e47a0f589fd1722ae81a6918ab372c29bc | """
A Printer for generating readable representation of most sympy classes.
"""
from __future__ import print_function, division
from typing import Any, Dict
from sympy.core import S, Rational, Pow, Basic, Mul, Number
from sympy.core.mul import _keep_coeff
from .printer import Printer
from sympy.printing.precedence i... |
45c2e0dfbd00e343649518c5f1e79c9baf43f8c96959b320a9124e5b3f3e89f0 | from __future__ import print_function, division
'''
Use llvmlite to create executable functions from Sympy expressions
This module requires llvmlite (https://github.com/numba/llvmlite).
'''
import ctypes
from sympy.external import import_module
from sympy.printing.printer import Printer
from sympy import S, Indexed... |
130704afecc9b5cbd2c14eb8bfb6dea1860d8b54cd5e8c88af7ea489e6f91644 | """
A Printer which converts an expression into its LaTeX equivalent.
"""
from __future__ import print_function, division
from typing import Any, Dict
import itertools
from sympy.core import Add, Mod, Mul, Number, S, Symbol
from sympy.core.alphabets import greeks
from sympy.core.containers import Tuple
from sympy.c... |
4aaa7f00423dc132ca204a98bc4d9ca6696fb6d9e77408621d1d05fe0f3de2be | """Printing subsystem driver
SymPy's printing system works the following way: Any expression can be
passed to a designated Printer who then is responsible to return an
adequate representation of that expression.
**The basic concept is the following:**
1. Let the object print itself if it knows how.
2. Take the be... |
844d5535a0b5745d07166a43fb742ecfc5960576ee0cac471fcf2f9e0b910c8e | """
Octave (and Matlab) code printer
The `OctaveCodePrinter` converts SymPy expressions into Octave expressions.
It uses a subset of the Octave language for Matlab compatibility.
A complete code generator, which uses `octave_code` extensively, can be found
in `sympy.utilities.codegen`. The `codegen` module can be us... |
cc9709eec7abc2176049c9e45f0c159019daf8a52e8157845ea5a668ca95141d | from __future__ import print_function, division
from sympy.core.basic import Basic
from sympy.core.expr import Expr
from sympy.core.symbol import Symbol
from sympy.core.numbers import Integer, Rational, Float
from sympy.printing.repr import srepr
__all__ = ['dotprint']
default_styles = (
(Basic, {'color': 'blue'... |
368a4c2a316e9ebac875acfd57aa1f95c7a2fcca6125f1e639c4ae6da40a01c6 | """
A Printer for generating executable code.
The most important function here is srepr that returns a string so that the
relation eval(srepr(expr))=expr holds in an appropriate environment.
"""
from __future__ import print_function, division
from typing import Any, Dict
from sympy.core.function import AppliedUndef... |
cae180b4449cf61cea2c486d952d424bccd190b7254bd7e5426611df9a9be779 | """
Julia code printer
The `JuliaCodePrinter` converts SymPy expressions into Julia expressions.
A complete code generator, which uses `julia_code` extensively, can be found
in `sympy.utilities.codegen`. The `codegen` module can be used to generate
complete source code files.
"""
from __future__ import print_funct... |
2fe480044d043bd13c9080985aeca8caec20b4fd0e53ebec5628437410acbffb | """Integration method that emulates by-hand techniques.
This module also provides functionality to get the steps used to evaluate a
particular integral, in the ``integral_steps`` function. This will return
nested namedtuples representing the integration rules used. The
``manualintegrate`` function computes the integra... |
da993095dbb9ade49b12479080f6d6f533faaab2f3e5f7232796fc86cd0cde50 | """ Integral Transforms """
from sympy.core import S
from sympy.core.compatibility import reduce, iterable
from sympy.core.function import Function
from sympy.core.relational import _canonical, Ge, Gt
from sympy.core.numbers import oo
from sympy.core.symbol import Dummy
from sympy.integrals import integrate, Integral
... |
741848ba0b827a05151f730873246ce22e52547ca09d992f4dd4d7edb2b478ef | from sympy.core import S, Dummy, pi
from sympy.functions.combinatorial.factorials import factorial
from sympy.functions.elementary.trigonometric import sin, cos
from sympy.functions.elementary.miscellaneous import sqrt
from sympy.functions.special.gamma_functions import gamma
from sympy.polys.orthopolys import (legendr... |
28a4b1c08fea4cc0c9d4e98c3f6c8bddc4ff4b9f67ca723141d16a0512e6da9f | """
Module to implement integration of uni/bivariate polynomials over
2D Polytopes and uni/bi/trivariate polynomials over 3D Polytopes.
Uses evaluation techniques as described in Chin et al. (2015) [1].
References
===========
[1] : Chin, Eric B., Jean B. Lasserre, and N. Sukumar. "Numerical integration
of homogeneou... |
6c2b8c762595c5f62c6a0463eed9e4561e306d0a0e4e1e1f6a04bcfb33a8ad81 | from sympy.concrete.expr_with_limits import AddWithLimits
from sympy.core.add import Add
from sympy.core.basic import Basic
from sympy.core.compatibility import is_sequence
from sympy.core.containers import Tuple
from sympy.core.expr import Expr
from sympy.core.function import diff
from sympy.core.logic import fuzzy_bo... |
b5300b7490a5fcf21615985c393bf85a487b9139011795241711816fe0bd3e39 | from typing import Dict, List
from itertools import permutations
from sympy.core.add import Add
from sympy.core.basic import Basic
from sympy.core.mul import Mul
from sympy.core.symbol import Wild, Dummy
from sympy.core.basic import sympify
from sympy.core.numbers import Rational, pi, I
from sympy.core.relational imp... |
9cc3eb6d9966239b6f36f80fff576f65ebc231da5fab034c9a14573674100f04 | """This module implements tools for integrating rational functions. """
from sympy import S, Symbol, symbols, I, log, atan, \
roots, RootSum, Lambda, cancel, Dummy
from sympy.polys import Poly, resultant, ZZ
def ratint(f, x, **flags):
"""
Performs indefinite integration of rational functions.
Given ... |
d7de370d311eba7bca9419364e51af4fded7e284c3f167d686c6282684bc64c4 | from sympy.core import Mul
from sympy.functions import DiracDelta, Heaviside
from sympy.core.compatibility import default_sort_key
from sympy.core.singleton import S
def change_mul(node, x):
"""change_mul(node, x)
Rearranges the operands of a product, bringing to front any simple
DiracDelta express... |
a1def61cfe998978ec820027a84337b22f5718fe32d47bd56a909a896faa6fc1 | from sympy.core import cacheit, Dummy, Ne, Integer, Rational, S, Wild
from sympy.functions import binomial, sin, cos, Piecewise
# TODO sin(a*x)*cos(b*x) -> sin((a+b)x) + sin((a-b)x) ?
# creating, each time, Wild's and sin/cos/Mul is expensive. Also, our match &
# subs are very slow when not cached, and if we create W... |
fec5533deda64e005530aaf1f201fe1a3f7c276784a395b11146d4714fd838d9 | """
Integrate functions by rewriting them as Meijer G-functions.
There are three user-visible functions that can be used by other parts of the
sympy library to solve various integration problems:
- meijerint_indefinite
- meijerint_definite
- meijerint_inversion
They can be used to compute, respectively, indefinite i... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.