hash stringlengths 64 64 | content stringlengths 0 1.51M |
|---|---|
742d8c7aef82f548bf9362e8cf2db52c4a26b381b6a4bb39c55ce8638a33b0e9 | 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... |
e88effafec41bc17b0a735af15c9860db4c15c14956562a78a8cccf03d4cc1a4 | from sympy import symbols
from sympy.functions import beta, Ei, zeta, Max, Min, sqrt
from sympy.printing.cxx import CXX98CodePrinter, CXX11CodePrinter, CXX17CodePrinter, cxxcode
from sympy.codegen.cfunctions import log1p
x, y = symbols('x y')
def test_CXX98CodePrinter():
assert CXX98CodePrinter().doprint(Max(x, ... |
62bc761e428ec70c68279ea8d2fb0e8e6d7c333cad11122b52f3eb109a51e7b7 | 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... |
c625929e33925e54cc04fb0f413d6f956dad2e23dbc8891927508b83ddec259a | from sympy import (sin, cos, atan2, log, exp, gamma, conjugate, sqrt,
factorial, Integral, Piecewise, Add, diff, symbols, S,
Float, Dummy, Eq, Range, Catalan, EulerGamma, E,
GoldenRatio, I, pi, Function, Rational, Integer, Lambda,
sign, Mod)
f... |
e55ad0c628714ea4b174056aac0ac3ca36958ca30ff66bda9d5b8fddb23703d9 | from sympy.core import (
S, pi, oo, symbols, Rational, Integer, Float, Mod, GoldenRatio, EulerGamma, Catalan,
Lambda, Dummy, Eq, nan, Mul, Pow
)
from sympy.functions import (
Abs, acos, acosh, asin, asinh, atan, atanh, atan2, ceiling, cos, cosh, erf,
erfc, exp, floor, gamma, log, loggamma, Max, Min, Pie... |
007e3a84e623918c1b2cfad9d31e7383302b6dcd201c1514efd5d2a4515e0741 | 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... |
147358d4450463964dea3429954665f5b982392fa672db1ac06f79ae0ec1b384 | from sympy.core import (S, pi, oo, symbols, Rational, Integer,
GoldenRatio, EulerGamma, Catalan, Lambda, Dummy,
Eq, Ne, Le, Lt, Gt, Ge)
from sympy.functions import (Piecewise, sin, cos, Abs, exp, ceiling, sqrt,
sign)
from sympy.logic import IT... |
05d87545cbac63347b95343cb374a293bcf0fc8362bd4716d804b8740d0e0ad8 | from sympy.printing.codeprinter import CodePrinter
from sympy.core import symbols
from sympy.core.symbol import Dummy
from sympy.testing.pytest import raises
def setup_test_printer(**kwargs):
p = CodePrinter(settings=kwargs)
p._not_supported = set()
p._number_symbols = set()
return p
def test_print_... |
7986db976757259a2344a2041263cfabf3098ac7cf659ef6628ba646ad1e8147 | 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.numpy_nodes import logaddexp, loga... |
55279c56a4d80d17d6811c1eacaa519d2dd87d794724fcce64a03585a744be9c | # -*- 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, ... |
9079194960eb0c7250be23e3fb53f2210a77d56595c238e8e63b2c8eed16d881 | """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,... |
e02b52613e59e027ed37ae6c6d07e20e1264b48dfe2168341c920bcf69daccca | """This tests sympy/core/basic.py with (ideally) no reference to subclasses
of Basic or Atom."""
import collections
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 sympy.core.sy... |
ea8781df38d3d640b73a5f630ed7820d6767c8901c812c1561bf45a5158976fd | from collections import defaultdict
from sympy import Matrix, Tuple, symbols, sympify, Basic, Dict, S, FiniteSet, Integer
from sympy.core.compatibility import is_sequence, iterable
from sympy.core.containers import tuple_wrapper
from sympy.core.expr import unchanged
from sympy.core.function import Function, Lambda
fro... |
aa2a60d4fcdd1ba39eca777fce257b89cd8c256430061d3b345f6ba8f5aff545 |
from sympy.interactive.session import int_to_Integer
def test_int_to_Integer():
assert int_to_Integer("1 + 2.2 + 0x3 + 40") == \
'Integer (1 )+2.2 +Integer (0x3 )+Integer (40 )'
assert int_to_Integer("0b101") == 'Integer (0b101 )'
assert int_to_Integer("ab1 + 1 + '1 + 2'") == "ab1 +Integer (1 )+'... |
75f842279cc42e6a283f128cafba1f01b1ded8df7ba8a8021bfb3f513f78038a | """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... |
21cbf899fbf7e5cc1abb760bd8e5d1c2a2e37029d87fecab6e0f9546873da621 | """Tests for computational algebraic number field theory. """
from sympy import (S, Rational, Symbol, Poly, sqrt, I, oo, Tuple, expand,
pi, cos, sin, exp, GoldenRatio, TribonacciConstant, cbrt)
from sympy.solvers.solveset import nonlinsolve
from sympy.geometry import Circle, intersection
from sympy.testing.pytest ... |
92450075c7abcfc16abc955bad8a1f98623285dd8a190f068fd34379e0bc14a6 | """Test sparse rational functions. """
from sympy.polys.fields import field, sfield, FracField, FracElement
from sympy.polys.rings import ring
from sympy.polys.domains import ZZ, QQ
from sympy.polys.orderings import lex
from sympy.testing.pytest import raises, XFAIL
from sympy.core import symbols, E
from sympy import... |
4a6dea1f599db30774a1b22f707cd34c4512f8aa91ee7d10a37a0650ddf21e66 | from sympy.core.compatibility import HAS_GMPY
from sympy.core.numbers import Rational
from sympy.matrices.common import (NonInvertibleMatrixError,
NonSquareMatrixError, ShapeError)
from sympy.matrices.dense import Matrix
from sympy.polys import ZZ, QQ
from sympy.polys.domainmatrix import (
DDM,
DDMB... |
06cf1846aa13f8f5b3f281f41a2464f5b5f1f9170b96acf25dd22bce9c5dc6f6 | # coding=utf-8
from os import walk, sep, pardir
from os.path import split, join, abspath, exists, isfile
from glob import glob
import re
import random
import ast
from sympy.testing.pytest import raises
from sympy.testing.quality_unicode import _test_this_file_encoding
# System path separator (usually slash or backsl... |
eca95280cd37db435a6ce39a1b377a19b239f4750abab95700ccaad2256bacc2 | from sympy import Eq, S, sqrt
from sympy.abc import x, y, z, s, t
from sympy.sets import FiniteSet, EmptySet
from sympy.geometry import Point
from sympy.vector import ImplicitRegion
from sympy.testing.pytest import raises
def test_ImplicitRegion():
ellipse = ImplicitRegion((x, y), (x**2/4 + y**2/16 - 1))
asse... |
78d3e86eb2e78833dc11811380752c7b2d1d989ed2974ef005e0e7c6186cf4e9 | """Hermitian conjugation."""
from sympy.core import Expr, Mul
from sympy.functions.elementary.complexes import adjoint
__all__ = [
'Dagger'
]
class Dagger(adjoint):
"""General Hermitian conjugate operation.
Take the Hermetian conjugate of an argument [1]_. For matrices this
operation is equivalent ... |
735fddc8edbd8dcc0c7156a58cd5db0f12da95a38e27fa3078b2ab2c16129e57 | """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... |
68bad736daf5e373868d8defd37f5bdaf0378f68cc93c8942cc4946a6fbd00f9 | """
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... |
fb319260a340a052c9590c052fbf232ea345a3f123150ddefdb3beebccf9d8d1 | """
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,... |
28a6b9db63c8219d00451cf8cd7e164227afcef36bfceb300131ed32068e2288 | from sympy import I, Matrix, symbols, conjugate, Expr, Integer, Mul
from sympy.physics.quantum.dagger import adjoint, Dagger
from sympy.external import import_module
from sympy.testing.pytest import skip
from sympy.physics.quantum.operator import Operator, IdentityOperator
def test_scalars():
x = symbols('x', co... |
4f0de92ae10294aa40dcfdcb1f6115687300aee578fd3b3e009ece6ca660a580 | from sympy import (Derivative, diff, Function, Integer, Mul, pi, sin, Symbol,
symbols)
from sympy.physics.quantum.qexpr import QExpr
from sympy.physics.quantum.dagger import Dagger
from sympy.physics.quantum.hilbert import HilbertSpace
from sympy.physics.quantum.operator import (Operator, UnitaryOper... |
ffb33c7c082d812f2b906e585addac7977888f2a2dd1e9d09e7e8fa47fcb4af5 | from sympy.physics.units.systems.si import dimsys_SI
from sympy import S, Symbol, sqrt
from sympy.physics.units.dimensions import Dimension
from sympy.physics.units.definitions.dimension_definitions import (
length, time, mass, force, pressure
)
from sympy.physics.units import foot
from sympy.testing.pytest import... |
dd00ea441ce7ee2f73f75d21e129b5e30ec502c5e973d572aba32a058296d171 | from __future__ import print_function, division
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.compatibility import SYMPY_INTS, Iterable
from sympy.printing.defaults import Printable
import iter... |
0d43e99e11c057978fd4e560e238b8758e7e7de2236ca366ce17025189c5fc28 | from sympy.assumptions import Q
from sympy.core.expr import Expr
from sympy.core.add import Add
from sympy.core.function import Function
from sympy.core.numbers import I, Integer, oo, pi, Rational
from sympy.core.singleton import S
from sympy.core.symbol import Symbol, symbols
from sympy.functions.elementary.complexes ... |
b1b240b700f7de262500ee5a4c4d3bd4964e3a43001c0ceb283ef96e1e4356e9 | import random
import concurrent.futures
from sympy import (
Abs, Add, E, Float, I, Integer, Max, Min, Poly, Pow, PurePoly, Rational,
S, Symbol, cos, exp, log, oo, pi, signsimp, simplify, sin,
sqrt, symbols, sympify, trigsimp, tan, sstr, diff, Function, expand)
from sympy.matrices.matrices import (ShapeErro... |
4c12088657de3cccae52bf9dbd82fa8f479a26cc6fd4a11e47bcc4b9f1dcaf3e | """ 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 Mat... |
e09b8744bd3fa66cbfae4b788699564a32d7de07c8423eeea28768804f979dd3 | 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... |
ef0ae2ad540b088de6c6700ec2473142c162e6bcc5efccf1c0a2b06af676d799 | from sympy.matrices.common import NonSquareMatrixError
from .matexpr import MatrixExpr
from .special import Identity
from sympy.core import S
from sympy.core.sympify import _sympify
from sympy.matrices import MatrixBase
class MatPow(MatrixExpr):
def __new__(cls, base, exp, evaluate=False, **options):
bas... |
766696303527d132e3c5ce63ca554666f29ca64b937ee868a060e7a94add1849 | from sympy.core import S
from sympy.core.sympify import _sympify
from sympy.functions import KroneckerDelta
from .matexpr import MatrixExpr
from .special import ZeroMatrix, Identity, OneMatrix
class PermutationMatrix(MatrixExpr):
"""A Permutation Matrix
Parameters
==========
perm : Permutation
... |
cd4ffb3536dc24ee04062a8691289c74ed94605e8fc67a7dbba373c44859d3a3 | from sympy.assumptions.ask import ask, Q
from sympy.core.relational import Eq
from sympy.core.singleton import S
from sympy.core.sympify import _sympify
from sympy.functions.special.tensor_functions import KroneckerDelta
from sympy.matrices.common import NonInvertibleMatrixError
from .matexpr import MatrixExpr
class ... |
2202fbbe15ec4c6c0aee488e42ee6d05df93d45dec757287476aaa65aaca0e35 | 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, Mul, Add
from sympy.core.decorators import call_highest_priority
from sympy.core.compatibility import SYMPY_INTS, default_sort_k... |
a36e5ea38a5917d635b91bbe506187660d5268b34c13b30b0ee3d894ec2f1d73 | """Implementation of the Kronecker product"""
from sympy.core import Mul, prod, sympify
from sympy.functions import adjoint
from sympy.matrices.common import ShapeError
from sympy.matrices.expressions.matexpr import MatrixExpr
from sympy.matrices.expressions.transpose import transpose
from sympy.matrices.expressions.... |
19ce6eccb4289a0aaf692d07e2023cb1e7bcc082196e981383b0bf8f4a923a9a | from sympy.core import Mul, sympify
from sympy.matrices.common import ShapeError
from sympy.matrices.expressions.matexpr import MatrixExpr
from sympy.matrices.expressions.special import ZeroMatrix, OneMatrix
from sympy.strategies import (
unpack, flatten, condition, exhaust, rm_id, sort
)
def hadamard_product(*ma... |
fdbde87f67681245d83f4b6194ddd2eb626f8472d6cfba1db9c5230823aca016 | 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... |
6999e2b444a5336f69da5dc252353bba9f822636fe39af8b413e100a68e8ddae | from sympy.core.logic import fuzzy_and
from sympy.core.sympify import _sympify
from sympy.sets.sets import Set
from .matexpr import MatrixExpr
class MatrixSet(Set):
"""
MatrixSet represents the set of matrices with ``shape = (n, m)`` over the
given set.
Examples
========
>>> from sympy.matri... |
e8e782b889340f42589df110cda7f0144fc9c58986feccda15b55d7572bfe202 | from sympy.core.compatibility import reduce
from operator import add
from sympy.core import Add, Basic, sympify
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.strategie... |
dceae7f6c322391a1bde965db14903ca6b1e18e0876ad7d45a0b1c58f56535a3 | from sympy.matrices.expressions import MatrixSymbol, MatAdd, MatPow, MatMul
from sympy.matrices.expressions.special import GenericZeroMatrix, ZeroMatrix
from sympy.matrices import eye, ImmutableMatrix
from sympy.core import Add, Basic, S
from sympy.testing.pytest import XFAIL, raises
X = MatrixSymbol('X', 2, 2)
Y = Ma... |
45f12d9dc792d99565d55af650c82fd03b35925120589588bac5a5e75d09b5cd | from sympy.core import I, symbols, Basic, Mul, S
from sympy.functions import adjoint, transpose
from sympy.matrices import (Identity, Inverse, Matrix, MatrixSymbol, ZeroMatrix,
eye, ImmutableMatrix)
from sympy.matrices.expressions import Adjoint, Transpose, det, MatPow
from sympy.matrices.expressions.special im... |
f59c8f6d206002c85721c6adb5bfc188be9b990639de312ac6feebd15fb71471 | from sympy.core.add import Add
from sympy.core.expr import unchanged
from sympy.core.mul import Mul
from sympy.core.symbol import symbols
from sympy.core.relational import Eq
from sympy.concrete.summations import Sum
from sympy.functions.elementary.piecewise import Piecewise
from sympy.matrices.common import NonSquareM... |
cd7077e5ffd5139bdfe20183fbea3a2a4bdf8b05e3fe329a20c719e1478ae3f6 | from sympy.combinatorics import Permutation
from sympy.core.expr import unchanged
from sympy.matrices import Matrix
from sympy.matrices.expressions import \
MatMul, BlockDiagMatrix, Determinant, Inverse
from sympy.matrices.expressions.matexpr import MatrixSymbol
from sympy.matrices.expressions.special import ZeroMa... |
e0fa5eb0181674e343fc189e5ae63365739cf492398effa21b8034edfc8ee9c8 | 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.special import OneMatrix
from sympy.testing.pytest import raises
from sympy ... |
5ed0f09311164866615895631acc10df713d4a6dcfd53ccf3d8a7b77ecc04833 | from sympy import (KroneckerDelta, diff, Sum, Dummy, factor,
expand, zeros, gcd_terms, Eq, Symbol)
from sympy.core import S, symbols, Add, Mul, SympifyError, Rational
from sympy.functions import sin, cos, sqrt, cbrt, exp
from sympy.simplify import simplify
from sympy.matrices import (ImmutableMatrix... |
e3296041dcf4438fe81fb1ba45d713fd1cb1a6d3d20611b5db707936f74e7ea9 | from sympy.core import Lambda, S, symbols
from sympy.concrete import Sum
from sympy.functions import adjoint, conjugate, transpose
from sympy.matrices import eye, Matrix, ShapeError, ImmutableMatrix
from sympy.matrices.expressions import (
Adjoint, Identity, FunctionMatrix, MatrixExpr, MatrixSymbol, Trace,
Zero... |
dd0187153424b3453ebbc5f9306ea784780d1bee0921d3a6984f85c08b4897ef | from sympy.core.singleton import S
from sympy.core.symbol import symbols
from sympy.matrices import Matrix
from sympy.matrices.expressions.matexpr import MatrixSymbol
from sympy.matrices.expressions.sets import MatrixSet
from sympy.matrices.expressions.special import ZeroMatrix
from sympy.testing.pytest import raises
... |
ec12017e79d9ff0c0d960926bf9a3f1701762104f61a2e9f7b76a99b04f8eb45 | #!/usr/bin/env python
"""
This script creates logos of different formats from the source "sympy.svg"
Requirements:
rsvg-convert - for converting to *.png format
(librsvg2-bin deb package)
imagemagick - for converting to *.ico favicon format
"""
from argparse import ArgumentParser
i... |
b7d2ac31c9cd1f65a43bbfcc76989bef21c29c6aa7133f5fc44ee76cd99b0189 | #!/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
from sympy.core.compatibility import clock
import sys
def display_fraction(digits, *, skip=0, colwidth=10, columns=5):
"""Pretty prin... |
c6d41d436b35d67d38a85700838b98330e05f788f2f32dd02f1ba9d9f9d07b39 | #!/usr/bin/env python
"""Functions example
Demonstrates functions defined in SymPy.
"""
from sympy import pprint, Symbol, log, exp
def main():
a = Symbol('a')
b = Symbol('b')
e = log((a + b)**5)
print()
pprint(e)
print('\n')
e = exp(e)
pprint(e)
print('\n')
e = log(exp((a +... |
dc358a970b09e0af6e9736409b08261a97fda94da4d1dd055a3768f438ba33f7 | #
# 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... |
6480717b30211127204d285100dc042a900c2d0355ea1ca9affe4f96dce2a560 | """
========
numpydoc
========
Sphinx extension that handles docstrings in the Numpy standard format. [1]
It will:
- Convert Parameters etc. sections to field lists.
- Convert See Also section to a See also entry.
- Renumber references.
- Extract the signature from the docstring, if it can't be determined
otherwis... |
2248de630455c3f3cec6bb376b68d3ad92ee9da2f97601ee90236ea67a91b87a | """
Extract reference documentation from the NumPy source tree.
"""
import inspect
import textwrap
import re
import pydoc
from collections.abc import Mapping
import sys
class Reader:
"""
A line-based string reader.
"""
def __init__(self, data):
"""
Parameters
----------
... |
c08cf1ba136941f90f7b230f728952047968d323c72b4383617ae65265ff42fb | import sys
import re
import inspect
import textwrap
import pydoc
import sphinx
import collections
from docscrape import NumpyDocString, FunctionDoc, ClassDoc
class SphinxDocString(NumpyDocString):
def __init__(self, docstring, config={}):
NumpyDocString.__init__(self, docstring, config=config)
se... |
0aba3f10c73bed89a1f601097c13b242b9595c34ee433e5fc3a6c5dbf7ddb4de | #
# 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... |
619186a3d51b1b1ab5e83f43085d16f0ec98157043068451ec530a6651eb4bbf | from __future__ import print_function, division
import random
import itertools
from typing import Sequence as tSequence, Union as tUnion
from sympy import (Matrix, MatrixSymbol, S, Indexed, Basic, Tuple, Range,
Set, And, Eq, FiniteSet, ImmutableMatrix, Integer,
Lambda, Mul, Dummy... |
937a7d333e1abcdd7c616bc49d7a9749e13384be92be92379158c9a01743b77a | from sympy import S, Basic, exp, multigamma, pi
from sympy.core.sympify import sympify, _sympify
from sympy.matrices import (ImmutableMatrix, Inverse, Trace, Determinant,
MatrixSymbol, MatrixBase, Transpose, MatrixSet,
matrix2numpy)
from sympy.stats.rv import (_va... |
baa72ef79c0725e25b40eb4c20ea19e0003ddcb87a7055b0a14742096b306da1 | """
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
======================... |
e950915320f48a84bd4c69d5afb6d82414f56ae272e3ad4695c4c5d0cd133d10 | from __future__ import print_function, division
from sympy.sets import FiniteSet
from sympy import (sqrt, log, exp, FallingFactorial, Rational, Eq, Dummy,
piecewise_fold, solveset, Integral)
from .rv import (probability, expectation, density, where, given, pspace, cdf, PSpace,
character... |
0a64f18284674c18a4ea4e68435a98f5353e749197b313e59354b97b755a4b28 | """
Joint Random Variables Module
See Also
========
sympy.stats.rv
sympy.stats.frv
sympy.stats.crv
sympy.stats.drv
"""
from __future__ import print_function, division
from sympy import (Basic, Lambda, sympify, Indexed, Symbol, ProductSet, S,
Dummy)
from sympy.concrete.products import Product
from ... |
47fe5ccddcece6a4123596061067fd5983514ba9da1281743c7870760390b06c | 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... |
12735d419e0af7b558e34f8dbecc7a641c8fc2cff59f44c073a06b61b66a1968 | """
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... |
f1c834c55439c3ddddb43ef80d8a7a07ad85609f401bf56701c02feac65a6c65 | from sympy import Basic, Sum, Dummy, Lambda, Integral
from sympy.stats.rv import (NamedArgsMixin, random_symbols, _symbol_converter,
PSpace, RandomSymbol, is_random)
from sympy.stats.crv import ContinuousDistribution, SingleContinuousPSpace
from sympy.stats.drv import DiscreteDistribution, Singl... |
c6473f10ce21a831d82ad63430d79ad023dd876cc5d4ce23a6c090eabbf666d5 | import itertools
from sympy import (Expr, Add, Mul, S, Integral, Eq, Sum, Symbol,
expand as _expand, Not)
from sympy.core.compatibility import default_sort_key
from sympy.core.parameters import global_parameters
from sympy.core.sympify import _sympify
from sympy.core.relational import Relational
fr... |
a370977ea98320fddde568b004e64c0797c8022e1db5654a780d8a57007ea4f5 | 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... |
88c25107aa1bf29aeb1bef70e86e129f0acfa3988fce11a6cfeff4bc09b2c0c9 | """
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... |
301b394ddc39c4080d32509d37c7d22e222cc10b9d6626c86c78c8f4be4111db | """
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, \
... |
2d9fb95a3c45c077dad56ba05a784d8b3d6cd6e104b25303810c2ba43055ae8a | from sympy.ntheory import sieve, isprime
from sympy.core.power import integer_log
from sympy.core.compatibility import as_int
import random
rgen = random.Random()
#----------------------------------------------------------------------------#
# ... |
0eb9b133e5f648f1e72041a89b7c43b3e9c1a21407de73b2abb6de07fdacf1ed | 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, ... |
253718bead22dc96b1e2610cda290664ea80a7571c4e5a13a9577d6243b39e0e | from sympy.core.numbers import igcd, mod_inverse
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=[], a=None, b=None):
"""This class den... |
02418af8841459068e09ea8ceb529684ed98fe8d0fac6be5c0eb6e151a9ff717 | """
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... |
dfa5d2128c4c10d73f4a63feb2c403c0246fb3547c7b4325f6944c9105ab3ec8 | 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... |
b9adcaed109ad54fa25df7c599539bb3c6b15e4483872912abac4526da5b70a6 | 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... |
1357d86a43a6453a6a92c7e929ae778fdd8c12e03b6dc525e2935a8931b946a8 | 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 ... |
8974a176873d022a1d176890606d201eab280759a96055b7e72413b81d3a1321 | """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... |
e71c1882b1a80e19b430cfca788c16cdf688a6e3866e80ec559a00a6a81f1fdc | 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... |
6af09592079f00423f45f2328655d285f794d1c9dd7480ae17ff4e59c54044be | 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... |
0c2551d6801eaf00f44f7d52dd29b8fb8351b069aa4a670fc9887ee0076ba793 | 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... |
698ef5e68466fdb6421f75dece9ba61abfec758fa20df968c35f992fc502c570 | 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... |
9692cffff4abc9cfa09bbc58f81d6c1268edf7dbb6ad9a2395e964e54d335583 | # 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... |
0da4ace31ad1bf5a52e981fa98f545e16273c2b3cec303366a326c3baaf43303 | from sympy.core.function import Add, ArgumentIndexError, Function
from sympy.core.singleton import S
from sympy.functions.elementary.trigonometric import cos, sin
def _cosm1(x, *, evaluate=True):
return Add(cos(x, evaluate=evaluate), -S.One, evaluate=evaluate)
class cosm1(Function):
""" Minus one plus cosin... |
b28838ef828d3f5f1c54f06e9b06803e76b2136fa5d1f6bbc0385cd7697c506f | """
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... |
7099d29d3ca8cb2e74f59186fcb1c0e35b8e53d965d317403bab488134005170 | from sympy import And, Gt, Lt, Abs, Dummy, oo, Tuple, Symbol
from sympy.codegen.ast import (
Assignment, AddAugmentedAssignment, CodeBlock, Declaration, FunctionDefinition,
Print, Return, Scope, While, Variable, Pointer, real
)
""" This module collects functions for constructing ASTs representing algorithms. "... |
39a39c824a3d20c19c5115b5568baca1f55b6459a1ec4bbff201f76a2f4be5a9 | """
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... |
1b6db4ee7a4e43c40636c55dab540356d01d24ea2e96dcbb3f607e93fc17831b | """
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
| ... |
8cb66285ffa024c8737d0ab1245a9e9b1602c70b3e36a133d95f478b70f3e58b | """
This file contains some classical ciphers and routines
implementing a linear-feedback shift register (LFSR)
and the Diffie-Hellman key exchange.
.. warning::
This module is intended for educational purposes only. Do not use the
functions in this module for real cryptographic applications. If you wish
to ... |
409445758707da3d6b62db40552ec6ca2584738699e3f911253d153065ebd17d | 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... |
52011bfda4737b86b25c62f58c6dcfdf540cadf0fc2d728ddb7a5048a289574e | """
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... |
561ce0c8c946893919e6fcfe07c3c545ca506281e17b1351bce3ca3d2b6413ac | """
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... |
2f84f83038f0c6a41f6b2abda25b99a9c34feff9e405564dec6bfd553fe541f9 | """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... |
0f6a331158b16d021b37ccf0aeec83189aaf761b031fdafba1983a7b61b6b0fe | """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... |
d3503de3a9897b8d03218266d51af949d49f19d5eca634894ae1d0723a9c0f75 | """
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... |
04c909e530344664abb184b36e6e1b7440b03ca0b4a0794e4f31cef3e476fa14 | """
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... |
ec735e5f9098859c9e2810d4abf6555921737452e689000c37265d5e45dd34e5 | 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... |
7701df53ab6e77e9944dbfe6429cec0da4ee027f31cef54594d796131c258484 | """ Generic SymPy-Independent Strategies """
from __future__ import print_function, division
from sympy.core.compatibility import get_function_name
identity = lambda x: x
def exhaust(rule):
""" Apply a rule repeatedly until it has no effect """
def exhaustive_rl(expr):
new, old = rule(expr), expr
... |
31c90a97a8004a0a2ed749e8a83b6a3ba1202224f47bb0648f4f7445db3e29f0 | """
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.utilities.exceptions import SymPyDeprecationWarning
fr... |
884be9e39b428daaa909d0ab3e53b5c6490310ecf225c450fc48d2d225fdd027 | 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... |
65f9084f3cf5a08732e7d0f1cd4f4c31cd7ddec4407479c4ae27826e408b6237 | """
Python code printers
This module contains python code printers for plain python as well as NumPy & SciPy enabled code.
"""
from collections import defaultdict
from itertools import chain
from sympy.core import S
from .precedence import precedence
from .codeprinter import CodePrinter
_kw_py2and3 = {
'and', 'as... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.