hash stringlengths 64 64 | content stringlengths 0 1.51M |
|---|---|
e8b0f7070c2fa0af3b27aa000193620aae283d249ab4b40ae6f33683115b7658 | from sympy.testing.pytest import raises, warns_deprecated_sympy
from sympy.vector.coordsysrect import CoordSys3D, CoordSysCartesian
from sympy.vector.scalar import BaseScalar
from sympy import sin, sinh, cos, cosh, sqrt, pi, ImmutableMatrix as Matrix, \
symbols, simplify, zeros, expand, acos, atan2
from sympy.vect... |
6b7e521049dd4ef76a594b327b831309df6955be6ee27c226815a29f4616466b | from sympy.vector import CoordSys3D, Gradient, Divergence, Curl, VectorZero, Laplacian
from sympy.printing.repr import srepr
R = CoordSys3D('R')
s1 = R.x*R.y*R.z # type: ignore
s2 = R.x + 3*R.y**2 # type: ignore
s3 = R.x**2 + R.y**2 + R.z**2 # type: ignore
v1 = R.x*R.i + R.z*R.z*R.j # type: ignore
v2 = R.x*R.i + R... |
e0ed484aeae71536fd41f904d08b059cab09404e233903341873718d85fc7b55 | # -*- coding: utf-8 -*-
from sympy import Integral, latex, Function
from sympy import pretty as xpretty
from sympy.vector import CoordSys3D, Vector, express
from sympy.abc import a, b, c
from sympy.core.compatibility import u_decode as u
from sympy.testing.pytest import XFAIL
def pretty(expr):
"""ASCII pretty-pri... |
88fe975f5311ce388de006c287f5e0db8d8dd639df156de65c4686c6cd955aee | from sympy import Dummy, S, symbols, pi, sqrt, asin, sin, cos, Rational
from sympy.geometry import Line, Point, Ray, Segment, Point3D, Line3D, Ray3D, Segment3D, Plane
from sympy.geometry.util import are_coplanar
from sympy.testing.pytest import raises
def test_plane():
x, y, z, u, v = symbols('x y z u v', real=Tr... |
952a774ea627f10fe1aceeb5eaa10de32372ffeab0d864e42d9800ed7edb4ebc | from sympy import (Eq, Rational, Float, S, Symbol, cos, oo, pi, simplify,
sin, sqrt, symbols, acos)
from sympy.functions.elementary.trigonometric import tan
from sympy.geometry import (Circle, GeometryError, Line, Point, Ray,
Segment, Triangle, intersection, Point3D, Line3D, Ray3D, Segment3D,
Point2D, Line2... |
7b61c191a3c5c84368b11b1308cc7d486582c030987d06b7924ccdab918dcd73 | from sympy import Eq, Rational, S, Symbol, symbols, pi, sqrt, oo, Point2D, Segment2D, Abs
from sympy.geometry import (Circle, Ellipse, GeometryError, Line, Point,
Polygon, Ray, RegularPolygon, Segment,
Triangle, intersection)
from sympy.testing.pytest import raise... |
54f7505542167115c7e0c1a62b15eae3d23ff9ce04af250685611218864d4719 | from sympy import Symbol, sqrt, Derivative, S, Function, exp
from sympy.geometry import Point, Point2D, Line, Polygon, Segment, convex_hull,\
intersection, centroid, Point3D, Line3D
from sympy.geometry.util import idiff, closest_points, farthest_points, _ordered_points, are_coplanar
from sympy.solvers.solvers impor... |
bd68d014b90a69419633d36ce0457ad1f1605b83a04e47ce986801c5974ad400 | from sympy import I, Rational, Symbol, pi, sqrt, S
from sympy.geometry import Line, Point, Point2D, Point3D, Line3D, Plane
from sympy.geometry.entity import rotate, scale, translate
from sympy.matrices import Matrix
from sympy.utilities.iterables import subsets, permutations, cartes
from sympy.testing.pytest import rai... |
8a637bc4a06e745b2d36a6f39a5e84c7011164fbf1bbc3052e45c8d5eaf9c4dd | from sympy import Symbol, Rational
from sympy.geometry import Circle, Ellipse, Line, Point, Polygon, Ray, RegularPolygon, Segment, Triangle
from sympy.geometry.entity import scale
from sympy.testing.pytest import raises
from random import random
def test_subs():
x = Symbol('x', real=True)
y = Symbol('y', rea... |
4e9e58add52cbd46bf49da307e0efb24be81dc853dba3cd01b2459510e52a4d7 | from sympy import (Abs, Rational, Float, S, Symbol, symbols, cos, sin, pi, sqrt, \
oo, acos)
from sympy.functions.elementary.trigonometric import tan
from sympy.geometry import (Circle, Ellipse, GeometryError, Point, Point2D, \
Polygon, Ray, RegularPolygon, Segment, Trian... |
85664639e43b1b096d4e3db1876e3c5279463bd0c2db8a6a25a5a327a89aa432 | from sympy import Rational, oo, sqrt, S
from sympy import Line, Point, Point2D, Parabola, Segment2D, Ray2D
from sympy import Circle, Ellipse, symbols, sign
from sympy.testing.pytest import raises
def test_parabola_geom():
a, b = symbols('a b')
p1 = Point(0, 0)
p2 = Point(3, 7)
p3 = Point(0, 4)
p4 ... |
16617aae2c3882c539f1742b1923338ff550927bae1983dd2b0add8266b9561e | from sympy import Symbol, pi, symbols, Tuple, S, sqrt, asinh, Rational
from sympy.geometry import Curve, Line, Point, Ellipse, Ray, Segment, Circle, Polygon, RegularPolygon
from sympy.testing.pytest import raises, slow
def test_curve():
x = Symbol('x', real=True)
s = Symbol('s')
z = Symbol('z')
# thi... |
01d367b51a19b4d0ea748537fa9e8c15d3972b375ebfe38df9ef5be25a5f5ada | from sympy.external import import_module
lfortran = import_module('lfortran')
if lfortran:
from sympy.codegen.ast import (Variable, IntBaseType, FloatBaseType, String,
Return, FunctionDefinition, Assignment)
from sympy.core import Add, Mul, Integer, Float
from sympy impo... |
76f9f3abac5e4b8dfcacdc13c25106d982e5f890430dc32510cfc84efbdbeb15 | from __future__ import unicode_literals, print_function
from sympy.external import import_module
import os
cin = import_module('clang.cindex', import_kwargs = {'fromlist': ['cindex']})
"""
This module contains all the necessary Classes and Function used to Parse C and
C++ code into SymPy expression
The module serves ... |
e7025c4cc89726d52b040f8752cb36961cf12bc489ef2bf08cdde7abbbf2c4bd | from sympy.parsing.sym_expr import SymPyExpression
from sympy.testing.pytest import raises
from sympy.external import import_module
lfortran = import_module('lfortran')
cin = import_module('clang.cindex', import_kwargs = {'fromlist': ['cindex']})
if lfortran and cin:
from sympy.codegen.ast import (Variable, IntBa... |
7a762b7e95ff185b3d440206b87b23dde40295e62a5de0e6d73d476e6355d9f5 | from sympy.testing.pytest import raises
from sympy.parsing.sym_expr import SymPyExpression
from sympy.external import import_module
lfortran = import_module('lfortran')
if lfortran:
from sympy.codegen.ast import (Variable, IntBaseType, FloatBaseType, String,
Return, FunctionDefi... |
3b955b4454ecc529ff73f7b394584c6b5fc0e8555ab023f30140a63430277d67 | from sympy import symbols, S
from sympy.parsing.ast_parser import parse_expr
from sympy.testing.pytest import raises
from sympy.core.sympify import SympifyError
def test_parse_expr():
a, b = symbols('a, b')
# tests issue_16393
parse_expr('a + b', {}) == a + b
raises(SympifyError, lambda: parse_expr('a ... |
be6eb455140a8259b039ee25244aacf6c19cd2c9516518bdd248b4aec27a8ea4 | import sympy
from sympy.parsing.sympy_parser import (
parse_expr,
standard_transformations,
convert_xor,
implicit_multiplication_application,
implicit_multiplication,
implicit_application,
function_exponentiation,
split_symbols,
split_symbols_custom,
_token_splittable
)
from symp... |
dd0510087f00956dd71ad4284b26c83db2e329000c8ad7b63ff865aa2f1744b8 | # -*- coding: utf-8 -*-
import sys
from sympy.core import Symbol, Function, Float, Rational, Integer, I, Mul, Pow, Eq
from sympy.functions import exp, factorial, factorial2, sin
from sympy.logic import And
from sympy.series import Limit
from sympy.testing.pytest import raises, skip
from sympy.parsing.sympy_parser ... |
605c2c5627bf53e47860699f18dbdde24b92f326660f8e115615eaddd4940515 | from sympy.testing.pytest import raises, XFAIL
from sympy.external import import_module
from sympy import (
Symbol, Mul, Add, Eq, Abs, sin, asin, cos, Pow,
csc, sec, Limit, oo, Derivative, Integral, factorial,
sqrt, root, StrictLessThan, LessThan, StrictGreaterThan,
GreaterThan, Sum, Product, E, log, t... |
32bc9a152178ac6919cd03f879a41eddf083edea407e3a36c8b1e8c75cbf76eb | from sympy.parsing.sym_expr import SymPyExpression
from sympy.testing.pytest import raises
from sympy.external import import_module
cin = import_module('clang.cindex', import_kwargs = {'fromlist': ['cindex']})
if cin:
from sympy.codegen.ast import (Variable, IntBaseType, FloatBaseType, String,
... |
eec01ae42ec3ae32abbdcc7c719849eeb0d546428463368f054c9141991178e2 | from sympy.external import import_module
from sympy.testing.pytest import ignore_warnings, raises
antlr4 = import_module("antlr4", warn_not_installed=False)
# disable tests if antlr4-python*-runtime is not present
if antlr4:
disabled = True
def test_no_import():
from sympy.parsing.latex import parse_latex
... |
52821789212c98208ee96cc15b068d9d4ac4d8ce50e128a0425eff46a3bc9187 | import os
from sympy import sin, cos
from sympy.external import import_module
from sympy.testing.pytest import skip
from sympy.parsing.autolev import parse_autolev
antlr4 = import_module("antlr4")
if not antlr4:
disabled = True
FILE_DIR = os.path.dirname(
os.path.dirname(os.path.abspath(os.path.realpath(__f... |
98526df705ee80d65911f97e6b6a04ea1b37179de9a1485d1d6e4db138a72d7b | import collections
import warnings
from sympy.external import import_module
autolevparser = import_module('sympy.parsing.autolev._antlr.autolevparser',
import_kwargs={'fromlist': ['AutolevParser']})
autolevlexer = import_module('sympy.parsing.autolev._antlr.autolevlexer',
... |
cde2d04ecf334dfabf8dd7c1997ad6d33e8a82b03f3b62773aa5a6618d30b76d | from sympy.external import import_module
from sympy.utilities.decorator import doctest_depends_on
@doctest_depends_on(modules=('antlr4',))
def parse_autolev(autolev_code, include_numeric=False):
"""Parses Autolev code (version 4.1) to SymPy code.
Parameters
=========
autolev_code : Can be an str or an... |
a5302d9bca87daf203232d13c845d09a00d615ee73e764a57276808a5ac9f7f9 | from sympy.external import import_module
autolevparser = import_module('sympy.parsing.autolev._antlr.autolevparser',
import_kwargs={'fromlist': ['AutolevParser']})
autolevlexer = import_module('sympy.parsing.autolev._antlr.autolevlexer',
import_kwargs={'froml... |
d744dcb4532993702896c9e24c9479ad0af5f505cda954f1fab97c6459070b8b | from sympy.external import import_module
from sympy.utilities.decorator import doctest_depends_on
from .errors import LaTeXParsingError # noqa
@doctest_depends_on(modules=('antlr4',))
def parse_latex(s):
r"""Converts the string ``s`` to a SymPy ``Expr``
Parameters
==========
s : str
The LaT... |
cad30b41bde5330cf09cb8606de46356fc947f404a384982b866a18f1f82042b | # Ported from latex2sympy by @augustt198
# https://github.com/augustt198/latex2sympy
# See license in LICENSE.txt
import sympy
from sympy.external import import_module
from sympy.printing.str import StrPrinter
from .errors import LaTeXParsingError
LaTeXParser = LaTeXLexer = MathErrorListener = None
try:
LaTeXP... |
219380dd4a3ad467373408dc2796283cd0a9ed49396c19e23f8be9b2b3f0aaef | """Shor's algorithm and helper functions.
Todo:
* Get the CMod gate working again using the new Gate API.
* Fix everything.
* Update docstrings and reformat.
"""
import math
import random
from sympy import Mul, S
from sympy import log, sqrt
from sympy.core.numbers import igcd
from sympy.ntheory import continued_fra... |
64217853ad9ee70f17a5d8a8303355e278b9de61ad2ba8a3d753a67dbf97c7e2 | """An implementation of qubits and gates acting on them.
Todo:
* Update docstrings.
* Update tests.
* Implement apply using decompose.
* Implement represent using decompose or something smarter. For this to
work we first have to implement represent for SWAP.
* Decide if we want upper index to be inclusive in the co... |
b8fecd64992e9bee880c443a625f4c7e59ebbbb094a3217428e7e0d6684d7a5a | from __future__ import print_function, division
from collections import deque
from random import randint
from sympy.external import import_module
from sympy import Mul, Basic, Number, Pow, Integer
from sympy.physics.quantum.represent import represent
from sympy.physics.quantum.dagger import Dagger
__all__ = [
# ... |
ac469f55f5158a494ed31078d832a10cd0bd44ca7c7d28a78e76222a283c2c1a | """ A module for mapping operators to their corresponding eigenstates
and vice versa
It contains a global dictionary with eigenstate-operator pairings.
If a new state-operator pair is created, this dictionary should be
updated as well.
It also contains functions operators_to_state and state_to_operators
for mapping b... |
2e70e5d55095552208355400c3ddb7644d8b999deb57f6151f7f96017b14c999 | """Abstract tensor product."""
from __future__ import print_function, division
from sympy import Expr, Add, Mul, Matrix, Pow, sympify
from sympy.core.trace import Tr
from sympy.printing.pretty.stringpict import prettyForm
from sympy.physics.quantum.qexpr import QuantumError
from sympy.physics.quantum.dagger import D... |
8ba1f679bc9692ef9858aa210277375eefa978fd7fe9c175a6e53883d00cc72f | """Dirac notation for states."""
from __future__ import print_function, division
from sympy import (cacheit, conjugate, Expr, Function, integrate, oo, sqrt,
Tuple)
from sympy.printing.pretty.stringpict import stringPict
from sympy.physics.quantum.qexpr import QExpr, dispatch_method
__all__ = [
... |
81501e0d6ab0b797a496062947a58845c01953fbb66ca973cd612d8064f5046c | """Functions for reordering operator expressions."""
import warnings
from sympy import Add, Mul, Pow, Integer
from sympy.physics.quantum import Operator, Commutator, AntiCommutator
from sympy.physics.quantum.boson import BosonOp
from sympy.physics.quantum.fermion import FermionOp
__all__ = [
'normal_order',
... |
910211e5e0823594f177ff6e2d4b6fa413d8185d321357f00ff5bf8d881f1dc4 | """Operators and states for 1D cartesian position and momentum.
TODO:
* Add 3D classes to mappings in operatorset.py
"""
from __future__ import print_function, division
from sympy import DiracDelta, exp, I, Interval, pi, S, sqrt
from sympy.physics.quantum.constants import hbar
from sympy.physics.quantum.hilbert i... |
638e0514e4cc0bdea68488f9b41cdfef5819c398839b5a7302ecd1ced38d5103 | """Utilities to deal with sympy.Matrix, numpy and scipy.sparse."""
from __future__ import print_function, division
from sympy import MatrixBase, I, Expr, Integer
from sympy.matrices import eye, zeros
from sympy.external import import_module
__all__ = [
'numpy_ndarray',
'scipy_sparse_matrix',
'sympy_to_nu... |
a1f8cc04011ae62a73cc482c710828ae0467d159891bb71fa937d6a22724b6e5 | """An implementation of gates that act on qubits.
Gates are unitary operators that act on the space of qubits.
Medium Term Todo:
* Optimize Gate._apply_operators_Qubit to remove the creation of many
intermediate Qubit objects.
* Add commutation relationships to all operators and use this in gate_sort.
* Fix gate_s... |
440db16ccec6845ab77553539dade87654c9607a8d7abc6335e6759308a01e2c | # Names exposed by 'from sympy.physics.quantum import *'
__all__ = [
'AntiCommutator',
'qapply',
'Commutator',
'Dagger',
'HilbertSpaceError', 'HilbertSpace', 'TensorProductHilbertSpace',
'TensorPowerHilbertSpace', 'DirectSumHilbertSpace', 'ComplexSpace', 'L2',
'FockSpace',
'InnerPr... |
5a4459ea9a7cc596e28e43976a4a2fc21918940521934936a37f8822ce866040 | """Logic for representing operators in state in various bases.
TODO:
* Get represent working with continuous hilbert spaces.
* Document default basis functionality.
"""
from __future__ import print_function, division
from sympy import Add, Expr, I, integrate, Mul, Pow
from sympy.physics.quantum.dagger import Dagger... |
b086aa5415b739711bca66a2d91cda89857290623269c273c56eb9539231e80d | """Qubits for quantum computing.
Todo:
* Finish implementing measurement logic. This should include POVM.
* Update docstrings.
* Update tests.
"""
from __future__ import print_function, division
import math
from sympy import Integer, log, Mul, Add, Pow, conjugate
from sympy.core.basic import sympify
from sympy.core... |
d38324fdee3348a5e828b6d4d46629b0df5c42f3b929718155fc6e78eccd03ec | from __future__ import print_function, division
from sympy import Expr, sympify, Symbol, Matrix
from sympy.printing.pretty.stringpict import prettyForm
from sympy.core.containers import Tuple
from sympy.core.compatibility import is_sequence
from sympy.physics.quantum.dagger import Dagger
from sympy.physics.quantum.ma... |
7be579be77425ab2742af66bba15ae5e6a9a4cecf35f275e43805d48a52c0a46 | """Grover's algorithm and helper functions.
Todo:
* W gate construction (or perhaps -W gate based on Mermin's book)
* Generalize the algorithm for an unknown function that returns 1 on multiple
qubit states, not just one.
* Implement _represent_ZGate in OracleGate
"""
from __future__ import print_function, divisio... |
db72aa3b0cefdfb6c58e194662fd7312bc90417dcff95aeddbc2751830dd0d82 | from __future__ import print_function, division
from itertools import product
from sympy import Tuple, Add, Mul, Matrix, log, expand, S
from sympy.core.trace import Tr
from sympy.printing.pretty.stringpict import prettyForm
from sympy.physics.quantum.dagger import Dagger
from sympy.physics.quantum.operator import Her... |
5181dbedf51321a4726f8695c0e211409a5a80ad6a5159b2bad3026d951b96e9 | """Quantum mechanical angular momemtum."""
from __future__ import print_function, division
from sympy import (Add, binomial, cos, exp, Expr, factorial, I, Integer, Mul,
pi, Rational, S, sin, simplify, sqrt, Sum, symbols, sympify,
Tuple, Dummy)
from sympy.core.compatibility import... |
74e89cdfd14fb665c671cd0c5eb096a98c42281359358f4c65f9164765e3560d | """Constants (like hbar) related to quantum mechanics."""
from __future__ import print_function, division
from sympy.core.numbers import NumberSymbol
from sympy.core.singleton import Singleton
from sympy.printing.pretty.stringpict import prettyForm
import mpmath.libmp as mlib
#---------------------------------------... |
5b204516bf3fa2f15510f538cc5a5a1beead344d5722b50d384c18fa3691278a | """Matplotlib based plotting of quantum circuits.
Todo:
* Optimize printing of large circuits.
* Get this to work with single gates.
* Do a better job checking the form of circuits to make sure it is a Mul of
Gates.
* Get multi-target gates plotting.
* Get initial and final states to plot.
* Get measurements to plo... |
c1a347d38d56d7b9734138ade6d92017ed8597a2db74fce2ab58d1cb5c421432 | #TODO:
# -Implement Clebsch-Gordan symmetries
# -Improve simplification method
# -Implement new simpifications
"""Clebsch-Gordon Coefficients."""
from __future__ import print_function, division
from sympy import (Add, expand, Eq, Expr, Mul, Piecewise, Pow, sqrt, Sum,
symbols, sympify, Wild)
from sy... |
8c85de85ad7053bf77609893d19fc974778fd6c5b4031eb248fbd70d76fd53f7 | """Primitive circuit operations on quantum circuits."""
from __future__ import print_function, division
from sympy import Symbol, Tuple, Mul, sympify, default_sort_key
from sympy.utilities import numbered_symbols
from sympy.core.compatibility import reduce
from sympy.physics.quantum.gate import Gate
__all__ = [
... |
433e6f818ad5bde40c5b996431739736743cf2f914b511d053eb8450fb7ebf29 | """Hilbert spaces for quantum mechanics.
Authors:
* Brian Granger
* Matt Curry
"""
from __future__ import print_function, division
from sympy import Basic, Interval, oo, sympify
from sympy.printing.pretty.stringpict import prettyForm
from sympy.physics.quantum.qexpr import QuantumError
from sympy.core.compatibilit... |
5ea998e87e730b252a8b8269470fe73c26dc36b45d934f0fdccf723022c3f483 | """Simple Harmonic Oscillator 1-Dimension"""
from __future__ import print_function, division
from sympy import sqrt, I, Symbol, Integer, S
from sympy.physics.quantum.constants import hbar
from sympy.physics.quantum.operator import Operator
from sympy.physics.quantum.state import Bra, Ket, State
from sympy.physics.qua... |
6ae2095d3cfc7215a8af1c1a0bda4ffaf5c39ddeaf2e5dc6f2dd8ce810755665 | """Logic for applying operators to states.
Todo:
* Sometimes the final result needs to be expanded, we should do this by hand.
"""
from __future__ import print_function, division
from sympy import Add, Mul, Pow, sympify, S
from sympy.physics.quantum.anticommutator import AntiCommutator
from sympy.physics.quantum.co... |
ba3485cb2b144d3dde858bcce0b9a72f0ca3a633c36644ddf797c6c2ee7f7a50 | from sympy.core.backend import Symbol
from sympy.physics.vector import Point, Vector, ReferenceFrame
from sympy.physics.mechanics import RigidBody, Particle, inertia
__all__ = ['Body']
# XXX: We use type:ignore because the classes RigidBody and Particle have
# inconsistent parallel axis methods that take different n... |
2f7400e7542c8935701d00e01bde4a599528007a729d2bcc8c9709d5c01e462c | from __future__ import print_function, division
from sympy.core.backend import zeros, Matrix, diff, eye
from sympy import solve_linear_system_LU
from sympy.utilities import default_sort_key
from sympy.physics.vector import (ReferenceFrame, dynamicsymbols,
partial_velocity)
from sympy.... |
ed684a8f921e10dd433a3afa5a88a85eba7e970d708e636ff0f3167a06edc7b6 | from __future__ import print_function, division
from sympy.core.backend import sympify
from sympy.physics.vector import Point, ReferenceFrame, Dyadic
from sympy.utilities.exceptions import SymPyDeprecationWarning
__all__ = ['RigidBody']
class RigidBody(object):
"""An idealized rigid body.
This is essenti... |
f8750fb620fb4dfee22c44fbc18b3f3962bf9b5c29e8d0a906c308bf54f60600 | from __future__ import print_function, division
from sympy.core.backend import sympify
from sympy.physics.vector import Point
from sympy.utilities.exceptions import SymPyDeprecationWarning
__all__ = ['Particle']
class Particle(object):
"""A particle.
Particles have a non-zero mass and lack spatial extensi... |
e65e3a06c8e924c9871a3d243a867cc574d2df5b46a7605fba7e6d62d8d91515 | # isort:skip_file
"""
Dimensional analysis and unit systems.
This module defines dimension/unit systems and physical quantities. It is
based on a group-theoretical construction where dimensions are represented as
vectors (coefficients being the exponents), and units are defined as a dimension
to which we added a scale... |
a9c94f8a984405bbcafba1a16a926fd414318358314562abd1fc0561d58167ce | """
Unit system for physical quantities; include definition of constants.
"""
from __future__ import division
from typing import Dict
from sympy import S, Mul, Pow, Add, Function, Derivative
from sympy.physics.units.dimensions import _QuantityMapper
from sympy.utilities.exceptions import SymPyDeprecationWarning
fr... |
539b1095d244ff8b14288c85f9edba4cfbbd4d2f50ff1755473300a9bcc492b7 | """
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... |
07293c4387239b9105cd801e224b2e523a901caac7904814eff75b823b36c7ae | """
Physical quantities.
"""
from __future__ import division
from sympy import AtomicExpr, Symbol, sympify
from sympy.physics.units.dimensions import _QuantityMapper
from sympy.physics.units.prefixes import Prefix
from sympy.utilities.exceptions import SymPyDeprecationWarning
class Quantity(AtomicExpr):
"""
... |
235cc465d21b6fd060567ad57d4cfb38786f48c62602e6dc6fc66a219b3031f7 | """
Module to handle gamma matrices expressed as tensor objects.
Examples
========
>>> from sympy.physics.hep.gamma_matrices import GammaMatrix as G, LorentzIndex
>>> from sympy.tensor.tensor import tensor_indices
>>> i = tensor_indices('i', LorentzIndex)
>>> G(i)
GammaMatrix(i)
N... |
015e6aabf6776f9869e270851fc05342e6a69c5d7d2d48f5f9b1d8501ed1308f | 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.conventions import split_super_sub
from sympy.printing.latex import LatexPrinter, translate
from sympy.printing.prett... |
a924971faf503dbabf610797baf525fcef87596652071fb30f5a6c2be73a38e6 | from __future__ import print_function, division
from .vector import Vector, _check_vector
from .frame import _check_frame
__all__ = ['Point']
class Point(object):
"""This object represents a point in a dynamic system.
It stores the: position, velocity, and acceleration of a point.
The position is a vect... |
b2e78fd743802462a80557452da048949de2e3abb955c9d8314339e440586b3a | from __future__ import print_function, division
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 C... |
0eb6c6f7d943f877f4ca18ed4e10cca4c935cde04f7e73f9e826d9eea881c2f2 | 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'... |
42c02b604b68d6150f05d772139169b8bc954948c393e1e25b9f1c46a12c8102 | from sympy import I, symbols
from sympy.physics.paulialgebra import Pauli
from sympy.testing.pytest import XFAIL
from sympy.physics.quantum import TensorProduct
sigma1 = Pauli(1)
sigma2 = Pauli(2)
sigma3 = Pauli(3)
tau1 = symbols("tau1", commutative = False)
def test_Pauli():
assert sigma1 == sigma1
assert... |
16d48ef1f988822ae9fc0acbbc4dc939678f9687723158ef78c99856469b5686 | from sympy import exp, integrate, oo, Rational, pi, S, simplify, sqrt, Symbol
from sympy.abc import omega, m, x
from sympy.physics.qho_1d import psi_n, E_n, coherent_state
from sympy.physics.quantum.constants import hbar
nu = m * omega / hbar
def test_wavefunction():
Psi = {
0: (nu/pi)**Rational(1, 4) * ... |
56de2363fa83e24e72a788b9aa810b035fd2f46aa14309e63187548060831718 | from sympy import exp, integrate, oo, S, simplify, sqrt, symbols, pi, sin, \
cos, I, Rational
from sympy.physics.hydrogen import R_nl, E_nl, E_nl_dirac, Psi_nlm
from sympy.testing.pytest import raises
n, r, Z = symbols('n r Z')
def feq(a, b, max_relative_error=1e-12, max_absolute_error=1e-12):
a = float(a)
... |
359b00e80470b9b7bb5694777c2e39fb90c560aad669608b35c4f77bbeb369ac | from sympy.core import symbols, Rational, Function, diff
from sympy.physics.sho import R_nl, E_nl
from sympy import simplify
def test_sho_R_nl():
omega, r = symbols('omega r')
l = symbols('l', integer=True)
u = Function('u')
# check that it obeys the Schrodinger equation
for n in range(5):
... |
33d418a5e6bd8b883d9fb3d56d7de074cfca3124ed18d444eb2affd487a85879 | from sympy.physics.secondquant import (
Dagger, Bd, VarBosonicBasis, BBra, B, BKet, FixedBosonicBasis,
matrix_rep, apply_operators, InnerProduct, Commutator, KroneckerDelta,
AnnihilateBoson, CreateBoson, BosonicOperator,
F, Fd, FKet, BosonState, CreateFermion, AnnihilateFermion,
evaluate_deltas, Ant... |
32562884ba986a3d05de5149f0e7a8de47a504909818e97e300327c9efa5f769 | from sympy.physics.pring import wavefunction, energy
from sympy import pi, integrate, sqrt, exp, simplify, I
from sympy.abc import m, x, r
from sympy.physics.quantum.constants import hbar
def test_wavefunction():
Psi = {
0: (1/sqrt(2 * pi)),
1: (1/sqrt(2 * pi)) * exp(I * x),
2: (1/sqrt(2 *... |
4377ba4ff8bda55683cd59069e15596bd832b8f4622deb4fae95425df4747888 | """
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,... |
6d1fbe91ebea266872a1e4f416e66bd589772dbf3b2a08193072c81f0de26eea | """
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... |
ec178b8e330763ad3e025eb385ca43329bea07708266628b3eb2af108eaa6c1f | from sympy import symbols, S, log, Rational
from sympy.core.trace import Tr
from sympy.external import import_module
from sympy.physics.quantum.density import Density, entropy, fidelity
from sympy.physics.quantum.state import Ket, TimeDepKet
from sympy.physics.quantum.qubit import Qubit
from sympy.physics.quantum.repre... |
e51eb4f530e69f666a89b2331a8cf8df3b43839b7beb4303681f802a56f04685 | from sympy import Float, I, Integer, Matrix
from sympy.external import import_module
from sympy.testing.pytest import skip
from sympy.physics.quantum.dagger import Dagger
from sympy.physics.quantum.represent import (represent, rep_innerproduct,
rep_expectation, enumerate_st... |
618834d89d10bce63364dc0b36b55344b137f79e4b97f4f3b3078e6370ad0be1 | from sympy import sqrt, exp, prod, Rational
from sympy.physics.quantum import Dagger, Commutator, qapply
from sympy.physics.quantum.boson import BosonOp
from sympy.physics.quantum.boson import (
BosonFockKet, BosonFockBra, BosonCoherentKet, BosonCoherentBra)
def test_bosonoperator():
a = BosonOp('a')
b = ... |
c11729508099d9875b51c99e1d9590cc50f406bcadddced1e4dd5a920fcb29b6 | 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... |
3cdd6eb4f9d95947fe07bad83b967287cd7d5cf519871365c7d3aadf15661bee | from sympy import exp, symbols, sqrt, I, pi, Mul, Integer, Wild, Rational
from sympy.matrices import Matrix, ImmutableMatrix
from sympy.physics.quantum.gate import (XGate, YGate, ZGate, random_circuit,
CNOT, IdentityGate, H, X, Y, S, T, Z, SwapGate, gate_simp, gate_sort,
CNotGate, TGate, HadamardGate, ... |
97afa4b4f847dad39cf5b91ee34d7e011e99059ff0a55fcf62bc0caca0820070 | from sympy import exp, I, Matrix, pi, sqrt, Symbol
from sympy.physics.quantum.qft import QFT, IQFT, RkGate
from sympy.physics.quantum.gate import (ZGate, SwapGate, HadamardGate, CGate,
PhaseGate, TGate)
from sympy.physics.quantum.qubit import Qubit
from sympy.physics.quantum.qap... |
408621abb2b2c4dad7129555e33c2dbe72196f966d3ed1bf687b0aaa79486f30 | from sympy import S
from sympy.physics.quantum.operatorset import (
operators_to_state, state_to_operators
)
from sympy.physics.quantum.cartesian import (
XOp, XKet, PxOp, PxKet, XBra, PxBra
)
from sympy.physics.quantum.state import Ket, Bra
from sympy.physics.quantum.operator import Operator
from sympy.phys... |
c4685cfeec5e42ad9444a930e1cd1c67e057622adae3c665eb8b758fa18297c6 | from sympy import I, Matrix, symbols, conjugate, Expr, Integer
from sympy.physics.quantum.dagger import adjoint, Dagger
from sympy.external import import_module
from sympy.testing.pytest import skip
def test_scalars():
x = symbols('x', complex=True)
assert Dagger(x) == conjugate(x)
assert Dagger(I*x) == ... |
12871bed7778731d3a6e7608bb541cf6bee7703965a72c26d0a213ccfef51e0d | from sympy import I, Mul, latex, Matrix
from sympy.physics.quantum import (Dagger, Commutator, AntiCommutator, qapply,
Operator, represent)
from sympy.physics.quantum.pauli import (SigmaOpBase, SigmaX, SigmaY, SigmaZ,
SigmaMinus, SigmaPlus,
... |
ddadc60a0e95e7f9a52766e5b685e29c6306be54b1a6aec696e6a90ffdd265a4 | from sympy.testing.pytest import XFAIL
from sympy.physics.quantum.qapply import qapply
from sympy.physics.quantum.qubit import Qubit
from sympy.physics.quantum.shor import CMod, getr
@XFAIL
def test_CMod():
assert qapply(CMod(4, 2, 2)*Qubit(0, 0, 1, 0, 0, 0, 0, 0)) == \
Qubit(0, 0, 1, 0, 0, 0, 0, 0)
... |
737bfdc14ccb1d41fe7815468fafdbae85611e48a8370a5a680a530c02447e55 | from sympy.physics.quantum.circuitplot import labeller, render_label, Mz, CreateOneQubitGate,\
CreateCGate
from sympy.physics.quantum.gate import CNOT, H, SWAP, CGate, S, T
from sympy.external import import_module
from sympy.testing.pytest import skip
mpl = import_module('matplotlib')
def test_render_label():
... |
dc457ff635b9ab479d4c0aad49dff63adcf356c04ebc39c6e334073b15a230a5 | from sympy import cos, exp, expand, I, Matrix, pi, S, sin, sqrt, Sum, symbols, Rational
from sympy.abc import alpha, beta, gamma, j, m
from sympy.physics.quantum import hbar, represent, Commutator, InnerProduct
from sympy.physics.quantum.qapply import qapply
from sympy.physics.quantum.tensorproduct import TensorProduct... |
8c775bd5f67753aa920cdf503b063e9c1f2be594fffed61055409283eb8f2b71 | import random
from sympy import Integer, Matrix, Rational, sqrt, symbols, S
from sympy.physics.quantum.qubit import (measure_all, measure_partial,
matrix_to_qubit, matrix_to_density,
qubit_to_matrix, IntQubit,
... |
c6707f3ce6311ae8317f2fcf2a75c186be9681546382fd75ca611055601507f4 | from random import randint
from sympy import Matrix, zeros, ones, Integer
from sympy.physics.quantum.matrixutils import (
to_sympy, to_numpy, to_scipy_sparse, matrix_tensor_product,
matrix_to_zero, matrix_zeros, numpy_ndarray, scipy_sparse_matrix
)
from sympy.external import import_module
from sympy.testing.... |
179952879f6f51c150de5adc9adaf330824f27a6ef8af024384e758ed5abce7d | # -*- encoding: utf-8 -*-
"""
TODO:
* Address Issue 2251, printing of spin states
"""
from typing import Dict, Any
from sympy.physics.quantum.anticommutator import AntiCommutator
from sympy.physics.quantum.cg import CG, Wigner3j, Wigner6j, Wigner9j
from sympy.physics.quantum.commutator import Commutator
from sympy.phy... |
2a39928ed2df78d9fce532f2749097eefd16fa301ca37cb89e70012f700135a4 | """Tests for sho1d.py"""
from sympy import Integer, Symbol, sqrt, I, S
from sympy.physics.quantum import Dagger
from sympy.physics.quantum.constants import hbar
from sympy.physics.quantum import Commutator
from sympy.physics.quantum.qapply import qapply
from sympy.physics.quantum.innerproduct import InnerProduct
from ... |
ee1a058c21c3f2dd1b4c35879befeb97426095034eeffd61793b7d9d14243118 | from sympy import Symbol, Integer, Mul
from sympy.utilities import numbered_symbols
from sympy.physics.quantum.gate import X, Y, Z, H, CNOT, CGate
from sympy.physics.quantum.identitysearch import bfs_identity_search
from sympy.physics.quantum.circuitutils import (kmp_table, find_subcircuit,
replace_subcircuit, ... |
d58900777b86717c67a7488c65f4968c8b02267ff564e66ee85cd44d21120ab1 | from sympy import (Add, conjugate, diff, I, Integer, Mul, oo, pi, Pow,
Rational, sin, sqrt, Symbol, symbols, sympify, S)
from sympy.testing.pytest import raises
from sympy.physics.quantum.dagger import Dagger
from sympy.physics.quantum.qexpr import QExpr
from sympy.physics.quantum.state import (
... |
a54900989bb832b248637e12b51c0ef628789abd864fd4c9fa77113fbdc71e96 | from sympy import symbols
from sympy.physics.mechanics import Point, Particle, ReferenceFrame, inertia
from sympy.testing.pytest import raises
def test_particle():
m, m2, v1, v2, v3, r, g, h = symbols('m m2 v1 v2 v3 r g h')
P = Point('P')
P2 = Point('P2')
p = Particle('pa', P, m)
assert p.__str__... |
ce50e844684dd5e7a954821f5ee7f34d6c9ad3a181ab0b4989889a3d0386b697 | from sympy.physics.mechanics import (dynamicsymbols, ReferenceFrame, Point,
RigidBody, LagrangesMethod, Particle,
inertia, Lagrangian)
from sympy import symbols, pi, sin, cos, tan, simplify, Function, \
Derivative, Matrix
def test_disc_on... |
b081a8bed0ce400f216c054ec4dda9b4483d3aa9928e0fe6bb0f2a9d8dd886d9 | from sympy.core.backend import sin, cos, tan, pi, symbols, Matrix, S
from sympy.physics.mechanics import (Particle, Point, ReferenceFrame,
RigidBody)
from sympy.physics.mechanics import (angular_momentum, dynamicsymbols,
inertia, inertia_of_point... |
a57d5923ca1233f6c5b905a020d1212ae8d93b75446407b87cf6769e6f93b178 | from sympy.testing.pytest import warns_deprecated_sympy
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,
Rig... |
23e7f2b816e7b99811d4e94eb56fc98248370afb2b7a091781fed2379b2305eb | 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... |
fea94d7e3e1569454d27f22e62f9c5ba4ef9d095624e3989be3586f5fe64e5e4 | from sympy import symbols
from sympy.physics.mechanics import Point, ReferenceFrame, Dyadic, RigidBody
from sympy.physics.mechanics import dynamicsymbols, outer, inertia
from sympy.physics.mechanics import inertia_of_point_mass
from sympy.core.backend import expand
from sympy.testing.pytest import raises
def test_ri... |
e01f55ad5a7b6419d723fa968a5e4f561931940996792d2f5985b29330f48783 | 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... |
4a23e9003e098a2ebc3f81f75aeaf78c9615aad993ee733ab2ad48ee8f2c8476 | 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, warns_deprecated_sympy
@slow
def test... |
4ec5d2c9eda12f7959fa5d1d6c0f1c4068f03d9b7458a5f079f1a71b491df047 | 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... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.