hash stringlengths 64 64 | content stringlengths 0 1.51M |
|---|---|
3d94dd2bc0060ee0dd5ff5e48335ba407a277e0523e46d4380e6a92ce85223dd | 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... |
b0be4e7bd99ecf303bd36a0c204d0fc7416800b84dfef4a3bddce3e450c73cc6 | from sympy.core.backend import (S, sympify, expand, sqrt, Add, zeros,
ImmutableMatrix as Matrix)
from sympy import trigsimp
from sympy.printing.defaults import Printable
from sympy.utilities.misc import filldedent
__all__ = ['Vector']
class Vector(Printable):
"""The class used to define vectors.
It alon... |
0530af17c54e82631ef3eaea98538d39b786040d5c60db4d07a88a6ea47bdb17 | from .vector import Vector, _check_vector
from .frame import _check_frame
from warnings import warn
__all__ = ['Point']
class Point:
"""This object represents a point in a dynamic system.
It stores the: position, velocity, and acceleration of a point.
The position is a vector defined as the vector dista... |
f9a0de95cd51bf676de9a2e97d64902d160bc3b31c80cde3b49264b046c7dc1e | from sympy.core.backend import (sympify, diff, sin, cos, Matrix, symbols,
Function, S, Symbol)
from sympy import integrate, trigsimp
from sympy.core.compatibility import reduce
from .vector import Vector, _check_vector
from .frame import CoordinateSym, _check_frame
from .dyadic import Dy... |
bb31a5e662f6793f654a6e3b85e31f67f216c4e831841bf7ce7472c4d5e7f9e7 | from sympy.core.backend import (diff, expand, sin, cos, sympify,
eye, symbols, ImmutableMatrix as Matrix, MatrixBase)
from sympy import (trigsimp, solve, Symbol, Dummy)
from sympy.physics.vector.vector import Vector, _check_vector
from sympy.utilities.misc import translate
__all__ = ['CoordinateSym'... |
67d885e2446d3ded95b835c507c4fe530a509f71d2e7e4a7f8df9d0a86424bcc | from sympy.core.backend import sympify, Add, ImmutableMatrix as Matrix
from sympy.printing.defaults import Printable
__all__ = ['Dyadic']
class Dyadic(Printable):
"""A Dyadic object.
See:
https://en.wikipedia.org/wiki/Dyadic_tensor
Kane, T., Levinson, D. Dynamics Theory and Applications. 1985 McGraw... |
255c3a4f5741a96ed707b0b07a89ef17519f1cce05857f8398477461d68ab232 | """
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... |
0cd4b90a5574e5561ef5909080c9b41e2108b5f3df59b42a05573dc4ac0c133c | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
The module implements routines to model the polarization of optical fields
and can be used to calculate the effects of polarization optical elements on
the fields.
- Jones vectors.
- Stokes vectors.
- Jones matrices.
- Mueller matrices.
Examples
--------
We calcula... |
08442178a965be7a1efb9be82314715484df77d6046bfaec00f50d54634d1fc6 | """
**Contains**
* Medium
"""
from sympy.physics.units import second, meter, kilogram, ampere
__all__ = ['Medium']
from sympy import Symbol, sympify, sqrt
from sympy.physics.units import speed_of_light, u0, e0
c = speed_of_light.convert_to(meter/second)
_e0mksa = e0.convert_to(ampere**2*second**4/(kilogram*meter**... |
28aea9b631848434f5804ee05552b0d4dd0a7f08b56fac1c0e7f0a46cc1c0546 | """
**Contains**
* refraction_angle
* fresnel_coefficients
* deviation
* brewster_angle
* critical_angle
* lens_makers_formula
* mirror_formula
* lens_formula
* hyperfocal_distance
* transverse_magnification
"""
__all__ = ['refraction_angle',
'deviation',
'fresnel_coefficients',
'brew... |
3978f144a70aec06e969e22939f80b9734ddcc46c0eae8693e5431b3652b115c | """
This module has all the classes and functions related to waves in optics.
**Contains**
* TWave
"""
__all__ = ['TWave']
from sympy import (sympify, pi, sin, cos, sqrt, Symbol, S,
symbols, Derivative, atan2)
from sympy.core.expr import Expr
from sympy.physics.units import speed_of_light, meter, second
c = s... |
f8fe0f2ed068833ac5ed5dc75820ff4f1caf010e45dd2e1ff962d806764b9599 | """
Gaussian optics.
The module implements:
- Ray transfer matrices for geometrical and gaussian optics.
See RayTransferMatrix, GeometricRay and BeamParameter
- Conjugation relations for geometrical and gaussian optics.
See geometric_conj*, gauss_conj and conjugate_gauss_beams
The conventions for the distance... |
2762a623822d2da367a0736bb31e5ddfc19d37c2ca5aee2c082843f09d638089 | from sympy.external import import_module
from sympy import Mul, Integer
from sympy.physics.quantum.dagger import Dagger
from sympy.physics.quantum.gate import (X, Y, Z, H, CNOT,
IdentityGate, CGate, PhaseGate, TGate)
from sympy.physics.quantum.identitysearch import (generate_gate_rules,
generate_equival... |
c8f324b59e734516caf4dd5a964937a2d6c23f901f5d4a595687040430ec6bea | from sympy.core.backend import (cos, expand, Matrix, sin, symbols, tan, sqrt, S,
zeros)
from sympy import simplify
from sympy.physics.mechanics import (dynamicsymbols, ReferenceFrame, Point,
RigidBody, KanesMethod, inertia, Particle,
... |
885d238b5cb6ac561774fabc80223c2fd8a348f47e752da3b81e615f2b9285f9 | from sympy.core.backend import symbols, Matrix, cos, sin, atan, sqrt, Rational
from sympy import solve, simplify, sympify
from sympy.physics.mechanics import dynamicsymbols, ReferenceFrame, Point,\
dot, cross, inertia, KanesMethod, Particle, RigidBody, Lagrangian,\
LagrangesMethod
from sympy.testing.pytest impo... |
40afb42e2e953a98c29c1211153f0785ea20fa6a2c6d4152995e46b16059b862 | from sympy.core.backend import symbols, Matrix, atan, zeros
from sympy import simplify
from sympy.physics.mechanics import (dynamicsymbols, Particle, Point,
ReferenceFrame, SymbolicSystem)
from sympy.testing.pytest import raises
# This class is going to be tested using a simple pen... |
c89c75e12a4fa4bd0d53e1e7aff895e114b45a2878a54b6cf7726e841e8314b6 | from sympy import evalf, symbols, pi, sin, cos, sqrt, acos, Matrix
from sympy.physics.mechanics import (ReferenceFrame, dynamicsymbols, inertia,
KanesMethod, RigidBody, Point, dot, msubs)
from sympy.testing.pytest import slow, ON_TRAVIS, skip
@slow
def test_bicycle():
if ON_TR... |
f3c4e5329fc8dc0a68d2ad722f2b970ee3475830cd0fff156b21a07878c60642 | from sympy.core.backend import cos, Matrix, sin, zeros, tan, pi, symbols
from sympy import trigsimp, simplify, solve
from sympy.physics.mechanics import (cross, dot, dynamicsymbols,
find_dynamicsymbols, KanesMethod, inertia,
inertia_of_point_mass... |
4dffed77a43518f14ead9037122cb59df72e0c3efa07059351949adea4ceff40 | """
MKS unit system.
MKS stands for "meter, kilogram, second".
"""
from sympy.physics.units import UnitSystem, DimensionSystem
from sympy.physics.units.definitions import G, Hz, J, N, Pa, W, c, g, kg, m, s
from sympy.physics.units.definitions.dimension_definitions import (
acceleration, action, energy, force, fre... |
aab8c618923d1f82f1847112104abbda4f4d7ba77a00b12de829fb1701c3b411 | """
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,
... |
e3739dbe6b717696f3f14716ff1a1113d02b25555d17b7607403760720c05f1e | """
Naturalunit system.
The natural system comes from "setting c = 1, hbar = 1". From the computer
point of view it means that we use velocity and action instead of length and
time. Moreover instead of mass we use energy.
"""
from sympy.physics.units import DimensionSystem
from sympy.physics.units.definitions import ... |
c0c74d5efa4392c33f83a3e83d92bbdf500aa13357ce0d28f59dae9c1d73c3e6 | """
SI unit system.
Based on MKSA, which stands for "meter, kilogram, second, ampere".
Added kelvin, candela and mole.
"""
from typing import List
from sympy.physics.units import DimensionSystem, Dimension, dHg0
from sympy.physics.units.quantities import Quantity
from sympy import Rational, pi, sqrt, S
from sympy.... |
b6c2dc7aa0d9150a6493ae6efe5e705f019c1d6bc7fbdbf2069ea6160e1956cd | from sympy.physics.vector import dynamicsymbols, Point, ReferenceFrame
from sympy.testing.pytest import raises, ignore_warnings
import warnings
def test_point_v1pt_theorys():
q, q2 = dynamicsymbols('q q2')
qd, q2d = dynamicsymbols('q q2', 1)
qdd, q2dd = dynamicsymbols('q q2', 2)
N = ReferenceFrame('N')... |
cbc7d6dfb28e598f5bb7bc60b8149fa46a888364970319876276cc63862af540 | from typing import Optional
from sympy import Derivative, Integer, Expr
from sympy.matrices.common import MatrixCommon
from .ndim_array import NDimArray
from .arrayop import derive_by_array
from sympy import MatrixExpr
from sympy import ZeroMatrix
from sympy.matrices.expressions.matexpr import _matrix_derivative
cla... |
ae7cf0ebdb928116d0831782c23535f5a723d9e8b58779f36472c1771df7a3bf | import functools, itertools
from sympy.core.sympify import sympify
from sympy.core.expr import Expr
from sympy.core import Basic
from sympy.tensor.array import ImmutableDenseNDimArray
from sympy import Symbol
from sympy.core.numbers import Integer
class ArrayComprehension(Basic):
"""
Generate a list comprehen... |
d7b1adfe40d0ea004c0089c81c480c8cf0b99475c3bddc1aacf399b7ed3778fd | import itertools
from sympy import S, Tuple, diff, Basic
from sympy.core.compatibility import Iterable
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 import SparseNDimArray
def _arr... |
c47bd464039176d09df3bba9c7cad9e0a7d898af97ed0a9387c178a40af76cb9 | 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):
... |
6170354f73775901d186a7af389fe78098c8385f4a738319fa196316344ebb84 | 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 itertools
class NDimArray(Printable):
"""
... |
6cb3f331286d35d029c34ede44eee7768af97b45885ce3a12733736b1e9146e5 | 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 ... |
017d807c581192abde2f504acc5f0f79dbf7d2abd07368a712acb4d510a69080 | from functools import wraps
from sympy import Matrix, eye, Integer, expand, Indexed, Sum
from sympy.combinatorics import Permutation
from sympy.core import S, Rational, Symbol, Basic, Add
from sympy.core.containers import Tuple
from sympy.core.symbol import symbols
from sympy.functions.elementary.miscellaneous import ... |
7aa1eeeb82beb561be415dc918238a4120a68411db1b3c9874585875e432bbb1 | from sympy.core import symbols, S, Pow, Function
from sympy.functions import exp
from sympy.testing.pytest import raises
from sympy.tensor.indexed import Idx, IndexedBase
from sympy.tensor.index_methods import IndexConformanceException
from sympy import get_contraction_structure, get_indices
def test_trivial_indices... |
3cb39e500c579d2be7d1a08a4d0b6f4c0680ea905b956397b18366e4fdfe69e0 | from sympy.testing.pytest import raises
from sympy import (
Array, ImmutableDenseNDimArray, ImmutableSparseNDimArray,
MutableDenseNDimArray, MutableSparseNDimArray, sin, cos,
simplify, Matrix
)
from sympy.abc import x, y
array_types = [
ImmutableDenseNDimArray,
ImmutableSparseNDimArray,
Mutable... |
752a30598bb7acd05e0e67df5f7c6ebcc194880a2cd9b882fa5ac0fd3e391548 | 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 ... |
090d640420696def66f419d0c66b405331dc1c332ae9a998d7eb81b386ce1883 | import random
from sympy.core.numbers import I
from sympy import symbols, Symbol, Rational, sqrt, Poly
from sympy.matrices import Matrix, eye, ones
from sympy.abc import x, y, z
from sympy.testing.pytest import raises
from sympy.matrices.matrices import MatrixDeterminant
from sympy.matrices.common import NonSquareMatri... |
ba3c7a6e551c7e83bd530d6e68d78363206939c006334f5b7f847f27a17030b6 | from sympy.testing.pytest import ignore_warnings
from sympy.utilities.exceptions import SymPyDeprecationWarning
from sympy.matrices import Matrix, SparseMatrix, ImmutableMatrix
with ignore_warnings(SymPyDeprecationWarning):
from sympy.matrices.densetools import eye
from sympy.matrices.densearith import add, s... |
6181d322587b90cfc8fa488541b238caaaa2cb77036ae224b191092d9e32ebdb | 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... |
4fa2a0ef6ebf7ff705992fd434e56968de3073bb54cb585a2cc883b52eacddb4 | 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',... |
5a08be1360ff803c3a1236e17abe787d75e8891d8eef7184744eb830c0879844 | from sympy.matrices.expressions import MatrixExpr
from sympy import Q
class Factorization(MatrixExpr):
arg = property(lambda self: self.args[0])
shape = property(lambda self: self.arg.shape) # type: ignore
class LofLU(Factorization):
predicates = Q.lower_triangular,
class UofLU(Factorization):
predic... |
20ca97092b0f874569fcc0bd1d94ee740e4318ce1606aff207e06cb746b3c8cf | """ 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... |
c6b0c9c87292a5629fae73512a497bc7bdab2518e8c4b006b44fb5b978a92708 | 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.... |
4900a05c117d21ea2f1df0a09d810b734cfd0752786a24c75bee39d66e052a28 | 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... |
d51ce6d593e859fbba20b3c59938dc53c53185c10b1f6f6e28b21ecbc6e57f02 | from sympy.core.sympify import _sympify
from sympy.matrices.expressions import MatrixExpr
from sympy import S, I, sqrt, exp
class DFT(MatrixExpr):
""" Discrete Fourier Transform """
def __new__(cls, n):
n = _sympify(n)
cls._check_dim(n)
obj = super().__new__(cls, n)
return obj
... |
e3fbd47ae7c28822115a44a41fa7b74bb8a8a530c50fa94d507eed3c369b666f | from sympy.core.sympify import _sympify
from sympy.matrices.expressions import MatrixExpr
from sympy.core import S, Eq, Ge
from sympy.functions.special.tensor_functions import KroneckerDelta
class DiagonalMatrix(MatrixExpr):
"""DiagonalMatrix(M) will create a matrix expression that
behaves as though all off-... |
c1231dc8afb1e7f5bde949d91a86ae348154d973f7621d93b748aa2bf92e3ff7 | from sympy.core.compatibility 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 transpos... |
f821c771797418542182b9d24479c1cec1b6b99859dbbb928bfa02ac90fc5ad1 | from sympy import Trace
from sympy.testing.pytest import raises, slow
from sympy.matrices.expressions.blockmatrix import (
block_collapse, bc_matmul, bc_block_plus_ident, BlockDiagMatrix,
BlockMatrix, bc_dist, bc_matadd, bc_transpose, bc_inverse,
blockcut, reblock_2x2, deblock)
from sympy.matrices.expressio... |
e02ffc6b73f11b516e8733a509e8e0de6c086473220a6138287d5e4f2fff4cab | from sympy.core.relational import Eq, is_eq
from sympy.core.basic import Basic
from sympy.core.logic import fuzzy_and, fuzzy_bool
from sympy.logic.boolalg import And
from sympy.multipledispatch import dispatch
from sympy.sets.sets import tfn, ProductSet, Interval, FiniteSet, Set
@dispatch(Interval, FiniteSet) # type:... |
ca4b52ab5e959cd32f5cc96800c37771dbd39d6979474a3bbe7604e671540555 | from sympy import symbols, S, oo
from sympy.core import Basic, Expr
from sympy.core.numbers import Infinity, NegativeInfinity
from sympy.multipledispatch import dispatch
from sympy.sets import Interval, FiniteSet
# XXX: The functions in this module are clearly not tested and are broken in a
# number of ways.
_x, _... |
3b1e03721fff6ebdd54bace8920fb58b4151259eee45aaf32369d032c870eb9d | from sympy import (Interval, Intersection, Set, EmptySet, S, sympify,
FiniteSet, Union, ComplexRegion, ProductSet)
from sympy.multipledispatch import dispatch
from sympy.sets.fancysets import (Naturals, Naturals0, Integers, Rationals,
Reals)
from sympy.sets.sets impo... |
da239d31ec439392f729ca113f704e46d6da38db2a9f8623d5648ef2316cfc83 | from sympy import Symbol, Contains, S, Interval, FiniteSet, oo, Eq
from sympy.core.expr import unchanged
from sympy.testing.pytest import raises
def test_contains_basic():
raises(TypeError, lambda: Contains(S.Integers, 1))
assert Contains(2, S.Integers) is S.true
assert Contains(-2, S.Naturals) is S.false
... |
1ec812f6de32cc32d4dd6d1cbf66aca61411fa4c4d4beb97280447b1a3f77fd4 | from sympy import (Symbol, Set, Union, Interval, oo, S, sympify, nan,
Max, Min, Float, DisjointUnion,
FiniteSet, Intersection, imageset, I, true, false, ProductSet,
sqrt, Complement, EmptySet, sin, cos, Lambda, ImageSet, pi,
Pow, Contains, Sum, rootof, SymmetricDifference, Piecewise,
Matrix, Range, ... |
797fdba2ff24d6530d8b5bae791e4fe636e2696d8fd8a01e3b7493cc55909dcf | from sympy import Symbol, sympify
from sympy.core.compatibility import is_sequence
from sympy.geometry.entity import GeometryEntity
from .plot_interval import PlotInterval
from .plot_object import PlotObject
from .util import parse_option_string
class PlotMode(PlotObject):
"""
Grandparent class for plotting
... |
c79bdfab3b44abeccdafa71b89dc654c995b03e9cc31aec95ee3c008129d5f47 | 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 creating a subclass
which overrides setup, u... |
2bc332b9d6114b617e92ee5b973916837ab78283033d4b17ab39872c353652a7 | try:
from ctypes import c_float
except ImportError:
pass
import pyglet.gl as pgl
from math import sqrt as _sqrt, acos as _acos
def cross(a, b):
return (a[1] * b[2] - a[2] * b[1],
a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0])
def dot(a, b):
return a[0] * b[0] + a[1] *... |
dbaab33b0c7fd30952014930757acef69ce4fb15d03d3fbdbf22acebf5505a00 | from threading import RLock
# it is sufficient to import "pyglet" here once
try:
import pyglet.gl as pgl
except ImportError:
raise ImportError("pyglet is required for plotting.\n "
"visit http://www.pyglet.org/")
from sympy.core.compatibility import is_sequence, SYMPY_INTS
from sympy.cor... |
d1c69f8769784c7f287a79eae63aa3e95ddaff564747a9dcf0d695b5958a1ee7 | import pyglet.gl as pgl
from sympy.core import S
from sympy.core.compatibility import is_sequence
from sympy.plotting.pygletplot.color_scheme import ColorScheme
from sympy.plotting.pygletplot.plot_mode import PlotMode
from time import sleep
from threading import Thread, Event, RLock
import warnings
class PlotModeBase... |
c9f90683b4c5df23e185150386f3cc4f5b898126e84f08003ad28e25d3fb77c1 | import pyglet.gl as pgl
from sympy.plotting.pygletplot.plot_rotation import get_spherical_rotatation
from sympy.plotting.pygletplot.util import get_model_matrix, model_to_screen, \
screen_to_model, vec_subs
class PlotCamera:
min_dist = 0.05
max_dist = 500.0
mi... |
52475dd7fbaa7505cf9dd0a34481984e005e2d995a9824d8f1283d2ae44df792 | from sympy import Basic, Symbol, symbols, lambdify
from .util import interpolate, rinterpolate, create_bounds, update_bounds
from sympy.utilities.iterables import sift
class ColorGradient:
colors = [0.4, 0.4, 0.4], [0.9, 0.9, 0.9]
intervals = 0.0, 1.0
def __init__(self, *args):
if len(args) == 2:... |
32ba092523c26c10d3f201acfc676aa55fca1ec96530d269c71d0c537bca255f | from pyglet.window import key
from pyglet.window.mouse import LEFT, RIGHT, MIDDLE
from sympy.plotting.pygletplot.util import get_direction_vectors, get_basis_vectors
class PlotController:
normal_mouse_sensitivity = 4.0
modified_mouse_sensitivity = 1.0
normal_key_sensitivity = 160.0
modified_key_sens... |
51c4051ae35a55b8cd4317cf63fa250f906e408f396972aeedaf3dc46a1ce114 | import pyglet.gl as pgl
from sympy.core import S
from sympy.plotting.pygletplot.plot_mode_base import PlotModeBase
class PlotCurve(PlotModeBase):
style_override = 'wireframe'
def _on_calculate_verts(self):
self.t_interval = self.intervals[0]
self.t_set = list(self.t_interval.frange())
... |
bdcd9f223554247cb015003250989c642179c93080efad08b310369fdc8a9bac | import pyglet.gl as pgl
from sympy.core import S
from sympy.plotting.pygletplot.plot_mode_base import PlotModeBase
class PlotSurface(PlotModeBase):
default_rot_preset = 'perspective'
def _on_calculate_verts(self):
self.u_interval = self.intervals[0]
self.u_set = list(self.u_interval.frange(... |
2f96c102d973aa8f649495d53bd1dfcec2ffe7053fe6b46cadf5c8df234e8673 | from sympy import Symbol, sympify
from sympy.core.numbers import Integer
class PlotInterval:
"""
"""
_v, _v_min, _v_max, _v_steps = None, None, None, None
def require_all_args(f):
def check(self, *args, **kwargs):
for g in [self._v, self._v_min, self._v_max, self._v_steps]:
... |
9192949a13fcfa23fc2e2456c020cd0b80b76f5249d9232ef0cf20154d4b4bdd | from sympy import lambdify
from sympy.core.numbers import pi
from sympy.functions import sin, cos
from sympy.plotting.pygletplot.plot_curve import PlotCurve
from sympy.plotting.pygletplot.plot_surface import PlotSurface
from math import sin as p_sin
from math import cos as p_cos
def float_vec3(f):
def inner(*arg... |
82a277fc468671851ed12f01172e97421ec914acb3bdd7269eebbddd829fbddd | try:
from ctypes import c_float, c_int, c_double
except ImportError:
pass
import pyglet.gl as pgl
from sympy.core import S
def get_model_matrix(array_type=c_float, glGetMethod=pgl.glGetFloatv):
"""
Returns the current modelview matrix.
"""
m = (array_type*16)()
glGetMethod(pgl.GL_MODELVIE... |
a86b7370aba9e08b750aa6768f103b167a2b0ae6b84bd23e07fec8dd21c18dc4 | class PlotObject:
"""
Base class for objects which can be displayed in
a Plot.
"""
visible = True
def _draw(self):
if self.visible:
self.draw()
def draw(self):
"""
OpenGL rendering code for the plot object.
Override in base class.
"""
... |
93eaa5fef658f6081ed502b16a00b9beb8216b67e4316924857c10164b888666 | from sympy.core.compatibility import clock
import pyglet.gl as pgl
from sympy.plotting.pygletplot.managed_window import ManagedWindow
from sympy.plotting.pygletplot.plot_camera import PlotCamera
from sympy.plotting.pygletplot.plot_controller import PlotController
class PlotWindow(ManagedWindow):
def __init__(s... |
f7ed9393049c81aa56221fabd01e7f6070be039fd07a97d353c0ebeaf453e294 | 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... |
6b4768d0dbbcf04f2984e79a3fc60bb97da79264e8dcdd326f22f1e708c2c2f2 | """
Interval Arithmetic for plotting.
This module does not implement interval arithmetic accurately and
hence cannot be used for purposes other than plotting. If you want
to use interval arithmetic, use mpmath's interval arithmetic.
The module implements interval arithmetic using numpy and
python floating points. The ... |
2f43ab96a7bd0f0dcf6c61ce3f63fc53c9040e920a49c3f8fa2fd7e72d61a468 | from sympy.plotting.intervalmath import interval
from sympy.external import import_module
from sympy.core.compatibility import reduce
""" The module contains implemented functions for interval arithmetic."""
def Abs(x):
if isinstance(x, (int, float)):
return interval(abs(x))
elif isinstance(x, interv... |
d55a4ed53ed48ef3f170cc920b91a1665f3e54cfc3c488ab4960b76469b12006 | from sympy.core.logic import fuzzy_and, fuzzy_or, fuzzy_not, fuzzy_xor
class intervalMembership:
"""Represents a boolean expression returned by the comparison of
the interval object.
Parameters
==========
(a, b) : (bool, bool)
The first value determines the comparison as follows:
... |
f2ca1194310f21081cb5f2f55caf0de6f08618e65bcc061f0a0d7988beed17ba | #!/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... |
ecd3541b88a7bddd06c3b0c479a3b7f428b5b5947b628c907e3e008db57fdd45 | #!/usr/bin/env python
"""
Test that only executable files have an executable bit set
"""
from __future__ import print_function
import os
import sys
from get_sympy import path_hack
base_dir = path_hack()
def test_executable(path):
if not os.path.isdir(path):
if os.access(path, os.X_OK):
with o... |
864d616b14830b1155725198c85f9d149cf668909931d533b9f3e9e198e25b2d | class TestsFailedError(Exception):
pass
print('Testing optional dependencies')
import sympy
test_list = [
# numpy
'*numpy*',
'sympy/core/',
'sympy/matrices/',
'sympy/physics/quantum/',
'sympy/utilities/tests/test_lambdify.py',
# scipy
'*scipy*',
# llvmlite
'*llvm*',
... |
acb4a84d6b44b95700e5a5eafec914d31541e8fe4934052068d8679d160a7f0c | #!/usr/bin/env python
"""
Test that
from sympy import *
doesn't import anything other than SymPy, it's hard dependencies (mpmath), and
hard optional dependencies (gmpy2). Importing unnecessary libraries
can accidentally add hard dependencies to SymPy in the worst case, or at best
slow down the SymPy import time when ... |
cb482834e0f2d52e694191d64b07cebf482d6c5022ea33a9ceaedcd3da52e45d | #!/usr/bin/env python
from subprocess import check_call
def run(*cmdline, cwd=None, env=None):
"""
Run command in subprocess and get lines of output
"""
return check_call(cmdline, encoding='utf-8', cwd=cwd, env=env)
|
4e1aba5e85a405de6e2755d23d184f886f66a8d4f0879eb57887ea9d33d9027b | #!/usr/bin/env python
import os
import json
from subprocess import check_output
from collections import OrderedDict, defaultdict
from collections.abc import Mapping
import glob
from contextlib import contextmanager
import requests
from requests_oauthlib import OAuth2
def main(version, push=None):
"""
WARNIN... |
fafa1158ab001865cc2e6106a659f59a1a133343e2bd8e08b563e33234a87840 | #!/usr/bin/env python3
import os
from pathlib import Path
from subprocess import check_output
import unicodedata
def main(version, outdir):
"""
Print authors text to put at the bottom of the release notes
"""
outdir = Path(outdir)
authors, authorcount, newauthorcount = get_authors(version)
a... |
67eefbcf90d5c670dc3ccb6a6b3903272bb355f721251a1f230634307538d6c7 | #!/usr/bin/env python3
import os
from pathlib import Path
from subprocess import check_output
def main(version, outdir):
outdir = Path(outdir)
build_files = [
outdir / f'sympy-{version}.tar.gz',
outdir / f'sympy-{version}-py3-none-any.whl',
outdir / f'sympy-docs-html-{version}.zip',
... |
441f489f234f099f7fc1b656c236ba524d62397a0f1bcae0b463d0757757952e | #!/usr/bin/env python3
from pathlib import Path
from tempfile import TemporaryDirectory
from subprocess import check_call
PY_VERSIONS = '3.6', '3.7', '3.8', '3.9'
def main(version, outdir):
for pyversion in PY_VERSIONS:
test_sdist(pyversion, version, outdir)
test_wheel(pyversion, version, outd... |
2cafdbefc9607abb992d8148687657da496c349b6d313bf0884cd4292556b7e0 | #!/usr/bin/env python3
import os
from os.path import dirname, join, basename, normpath
from os import chdir
import shutil
from helpers import run
ROOTDIR = dirname(dirname(__file__))
DOCSDIR = join(ROOTDIR, 'doc')
def main(version, outputdir):
os.makedirs(outputdir, exist_ok=True)
build_html(DOCSDIR, out... |
a79c73f478cec0680590def7485a90b117ff50b44d852bbd20ba281fb7f457ab | #!/usr/bin/env python3
from os.path import join, basename, normpath
from subprocess import check_call
def main(version, outdir):
check_version(version, outdir)
run_stage(['bin/mailmap_update.py'])
run_stage(['bin/authors_update.py'])
run_stage(['mkdir', '-p', outdir])
build_release_files('bdist_wh... |
097fae90e229d2654205b8dcba5c89cc96b9942de6bfa3857ea8cc66689c8f12 | #!/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)
"""
... |
f8cf1fb5af3e9585a1bb289dc2eead6e301aba7d1aaa3cb3c5024d8060a42bce | """
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... |
efcaaa9b88bd2674dad4f87634df43820d7ba1b6be3e86a952f421b145b7e549 | """
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 ``C``, ``O``, ``S``,... |
0d5894384723fba57ca68df70fa6373741e3ba2ff6f2895e0708775e706b904e | #
# 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... |
29940a5ec4bd87b770a7e0d608d4de2abfa660e2a92244176eabedef583246aa | """
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... |
b67372fdc6405e50ee8e075929b0b7056124aed52e4088ccc37f770f0f1c37cc | """
Finite Discrete Random Variables - Prebuilt variable types
Contains
========
FiniteRV
DiscreteUniform
Die
Bernoulli
Coin
Binomial
BetaBinomial
Hypergeometric
Rademacher
IdealSoliton
RobustSoliton
"""
from sympy import (S, sympify, Rational, binomial, cacheit, Integer,
Dummy, Eq, Intersection, ... |
eb974a4d1c1a419c12fe486929897942998b0f6a1fea1f1f769383ba8fae9705 | import random
import itertools
from typing import Sequence as tSequence, Union as tUnion, List as tList, Tuple as tTuple
from sympy import (Matrix, MatrixSymbol, S, Indexed, Basic, Tuple, Range,
Set, And, Eq, FiniteSet, ImmutableMatrix, Integer, igcd,
Lambda, Mul, Dummy, IndexedB... |
502e68cca20d23031d7ec21ff56ad0756d184911298049c34749c96915827f85 | """
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
======================... |
ca13e19986380434e1ced312faf456953732e42781b11503dfa26c310aaef387 | 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,
characteristic_function, sample, sample_iter, random_symb... |
47825f21a1b1593c0fa4084d1dcf8f0eefa2d3bcbace107b94df2295a79ba00a | """
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... |
d973148f9efc8d7bfc9d58afc0d1f6ef6d7c2fd513bcbae60bc376143c11a364 | from sympy import (Basic, sympify, symbols, Dummy, Lambda, summation,
Piecewise, S, cacheit, Sum, exp, I, Ne, Eq, poly,
series, factorial, And, lambdify, floor)
from sympy.polys.polyerrors import PolynomialError
from sympy.stats.crv import reduce_rational_inequalities_wrap
from sy... |
2ae7b48f67f20e4ee5d9c971e9d414c804d735eacbb28149f987765458d653e6 | """
Continuous Random Variables Module
See Also
========
sympy.stats.crv_types
sympy.stats.rv
sympy.stats.frv
"""
from sympy import (Interval, Intersection, symbols, sympify, Dummy, nan,
Integral, And, Or, Piecewise, cacheit, integrate, oo, Lambda,
Basic, S, exp, I, FiniteSet, Ne, Eq, Union, poly, se... |
be507ffc1a7ae14a69fe5cdd52f58c21d9020b8464fb4738d3026478e28f70b3 | from functools import reduce
from sympy.core.compatibility import as_int
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):... |
c21d7b4463fce6c88e7478228735a006a9bb74bbfcb33a33c5fdb451018f9393 | 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.compatibility import \
is_sequence, as_int
from sympy.core.numbe... |
8a85932bd7267ca46945fa15ba79f2e0ebeaced620d8d297c4b5cc92ad0f48d4 | 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, default_sort_key)
rmul = P... |
783f3175a1a2507825fc79ff0bc857692cb863b2a1b4a2fa3b8d1861808d3852 | from sympy.core import Basic, Dict, sympify
from sympy.core.compatibility import as_int, default_sort_key
from sympy.core.sympify import _sympify
from sympy.functions.combinatorial.numbers import bell
from sympy.matrices import zeros
from sympy.sets.sets import FiniteSet, Union
from sympy.utilities.iterables import fla... |
365656a7a8a5d2c9e6e07a96cdd87e0c29c486663fff9d1871d03178ac4a454e | 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... |
9e61e99fd8a0418741dc0bf7d514f82e081b2c103f0c37e6008b8ef02750b7f2 | from sympy.concrete.expr_with_limits import ExprWithLimits
from sympy.core.singleton import S
from sympy.core.relational import Eq
class ReorderError(NotImplementedError):
"""
Exception raised when trying to reorder dependent limits.
"""
def __init__(self, expr, msg):
super().__init__(
... |
ad2eb8fa80bb8dc6e3deae495b0ddd83ff8c68ec03169ecd3da62eef68a7356e | """
This module implements sums and products containing the Kronecker Delta function.
References
==========
.. [1] 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.funct... |
8cd8f03be569e69927be0799922d2f746caf5cd266cdbcbe61fefc3b16dc4f38 | """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):
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.