sympy の API リファレンス

sympy (sympy/sympy) の公開 API 400 件 —— クラス 219、関数 66、メソッド 115。実際のソースを静的解析して抽出した正確なシグネチャを掲載しています。

リポジトリ: sympy/sympy

種別	件数
クラス	219
関数	66
メソッド	115

API 一覧

funcbin.get_sympy.path_hack()

Hack sys.path to import correct (local) sympy.

func

release.github_release.query_GitHub(url, username=None, password=None, token=None, data=None, OTP=None, headers=None, params=None, files=None)

Query GitHub API.

funcrelease.github_release.release_files(version)

Returns the list of local release files

funcrelease.github_release.table(version)

Make an html table of the downloads.

funcrelease.update_docs.run(*cmdline, **kwargs)

Run subprocess with cwd in sympy_doc

classsympy.algebras.quaternion.Quaternion

Provides basic quaternion operations.

methodsympy.algebras.quaternion.Quaternion.add(other:SExpr | Quaternion) -> Quaternion

Adds quaternions.

methodsympy.algebras.quaternion.Quaternion.axis() -> Quaternion

Returns $\mathbf{Ax}(q)$, the axis of the quaternion $q$.

methodsympy.algebras.quaternion.Quaternion.exp() -> Quaternion

Returns the exponential of $q$, given by $e^q$.

methodsympy.algebras.quaternion.Quaternion.from_Matrix(elements:Matrix | Sequence[SExpr]) -> Quaternion

Returns quaternion from elements of a column vector`.

methodsympy.algebras.quaternion.Quaternion.index_vector() -> Quaternion

Returns the index vector of the quaternion.

methodsympy.algebras.quaternion.Quaternion.integrate(*symbols:SymbolLimits) -> Quaternion

Computes integration of quaternion.

methodsympy.algebras.quaternion.Quaternion.inverse() -> Quaternion

Returns the inverse of the quaternion.

methodsympy.algebras.quaternion.Quaternion.log()

Returns the logarithm of the quaternion, given by $\log q$.

methodsympy.algebras.quaternion.Quaternion.mul(other:SExpr | Quaternion) -> Quaternion

Multiplies quaternions.

methodsympy.algebras.quaternion.Quaternion.norm() -> Expr

Returns the norm of the quaternion.

methodsympy.algebras.quaternion.Quaternion.normalize() -> Quaternion

Returns the normalized form of the quaternion.

methodsympy.algebras.quaternion.Quaternion.orthogonal(other:Quaternion) -> bool | None

Returns the orthogonality of two quaternions.

methodsympy.algebras.quaternion.Quaternion.pow(p:int) -> Quaternion

Finds the pth power of the quaternion.

methodsympy.algebras.quaternion.Quaternion.pow_cos_sin(p:int) -> Quaternion

Computes the pth power in the cos-sin form.

methodsympy.algebras.quaternion.Quaternion.scalar_part() -> Expr

Returns scalar part($\mathbf{S}(q)$) of the quaternion q.

methodsympy.algebras.quaternion.Quaternion.set_norm(norm:SExpr | None) -> None

Sets norm of an already instantiated quaternion.

methodsympy.algebras.quaternion.Quaternion.to_Matrix(vector_only:bool=False) -> Matrix

Returns elements of quaternion as a column vector.

classsympy.assumptions.ask.AssumptionKeys

This class contains all the supported keys by ``ask``.

classsympy.assumptions.assume.AppliedPredicate

The class of expressions resulting from applying ``Predicate`` to the arguments.

methodsympy.assumptions.assume.AppliedPredicate.function()

Return the predicate.

classsympy.assumptions.assume.Predicate

Base class for mathematical predicates.

methodsympy.assumptions.assume.Predicate.register(*types, **kwargs)

classsympy.assumptions.assume.UndefinedPredicate

Predicate without handler.

funcsympy.assumptions.assume.assuming(*assumptions)

Context manager for assumptions.

classsympy.assumptions.cnf.AND

A low-level implementation for And

classsympy.assumptions.cnf.CNF

Class to represent CNF of a Boolean expression.

classsympy.assumptions.cnf.EncodedCNF

Class for encoding the CNF expression.

classsympy.assumptions.cnf.Literal

The smallest element of a CNF object.

classsympy.assumptions.cnf.OR

A low-level implementation for Or

funcsympy.assumptions.facts.get_known_facts(x=None)

Facts between unary predicates.

funcsympy.assumptions.facts.get_matrix_facts(x=None)

Facts between unary matrix predicates.

funcsympy.assumptions.facts.get_number_facts(x=None)

Facts between unary number predicates.

funcsympy.assumptions.handlers.matrices.BM_elements(predicate, expr, assumptions)

Block Matrix elements.

funcsympy.assumptions.handlers.matrices.MS_elements(predicate, expr, assumptions)

Matrix Slice elements.

classsympy.assumptions.predicates.calculus.FinitePredicate

Finite number predicate.

classsympy.assumptions.predicates.calculus.InfinitePredicate

Infinite number predicate.

classsympy.assumptions.predicates.calculus.NegativeInfinitePredicate

Negative infinity predicate.

classsympy.assumptions.predicates.calculus.PositiveInfinitePredicate

Positive infinity predicate.

classsympy.assumptions.predicates.common.CommutativePredicate

Commutative predicate.

classsympy.assumptions.predicates.common.IsTruePredicate

Generic predicate.

classsympy.assumptions.predicates.matrices.ComplexElementsPredicate

Complex elements matrix predicate.

classsympy.assumptions.predicates.matrices.DiagonalPredicate

Diagonal matrix predicate.

classsympy.assumptions.predicates.matrices.FullRankPredicate

Fullrank matrix predicate.

classsympy.assumptions.predicates.matrices.IntegerElementsPredicate

Integer elements matrix predicate.

classsympy.assumptions.predicates.matrices.InvertiblePredicate

Invertible matrix predicate.

classsympy.assumptions.predicates.matrices.LowerTriangularPredicate

Lower triangular matrix predicate.

classsympy.assumptions.predicates.matrices.NormalPredicate

Normal matrix predicate.

classsympy.assumptions.predicates.matrices.OrthogonalPredicate

Orthogonal matrix predicate.

classsympy.assumptions.predicates.matrices.PositiveDefinitePredicate

Positive definite matrix predicate.

classsympy.assumptions.predicates.matrices.RealElementsPredicate

Real elements matrix predicate.

classsympy.assumptions.predicates.matrices.SingularPredicate

Singular matrix predicate.

classsympy.assumptions.predicates.matrices.SquarePredicate

Square matrix predicate.

classsympy.assumptions.predicates.matrices.SymmetricPredicate

Symmetric matrix predicate.

classsympy.assumptions.predicates.matrices.TriangularPredicate

Triangular matrix predicate.

classsympy.assumptions.predicates.matrices.UnitTriangularPredicate

Unit triangular matrix predicate.

classsympy.assumptions.predicates.matrices.UnitaryPredicate

Unitary matrix predicate.

classsympy.assumptions.predicates.matrices.UpperTriangularPredicate

Upper triangular matrix predicate.

classsympy.assumptions.predicates.ntheory.CompositePredicate

Composite number predicate.

classsympy.assumptions.predicates.ntheory.EvenPredicate

Even number predicate.

classsympy.assumptions.predicates.ntheory.OddPredicate

Odd number predicate.

classsympy.assumptions.predicates.ntheory.PrimePredicate

Prime number predicate.

classsympy.assumptions.predicates.order.ExtendedNegativePredicate

Negative extended real number predicate.

classsympy.assumptions.predicates.order.ExtendedNonNegativePredicate

Nonnegative extended real number predicate.

classsympy.assumptions.predicates.order.ExtendedNonPositivePredicate

Nonpositive extended real number predicate.

classsympy.assumptions.predicates.order.ExtendedNonZeroPredicate

Nonzero extended real number predicate.

classsympy.assumptions.predicates.order.ExtendedPositivePredicate

Positive extended real number predicate.

classsympy.assumptions.predicates.order.NegativePredicate

Negative number predicate.

classsympy.assumptions.predicates.order.NonNegativePredicate

Nonnegative real number predicate.

classsympy.assumptions.predicates.order.NonPositivePredicate

Nonpositive real number predicate.

classsympy.assumptions.predicates.order.NonZeroPredicate

Nonzero real number predicate.

classsympy.assumptions.predicates.order.PositivePredicate

Positive real number predicate.

classsympy.assumptions.predicates.order.ZeroPredicate

Zero number predicate.

classsympy.assumptions.predicates.sets.AlgebraicPredicate

Algebraic number predicate.

classsympy.assumptions.predicates.sets.AntihermitianPredicate

Antihermitian predicate.

classsympy.assumptions.predicates.sets.ComplexPredicate

Complex number predicate.

classsympy.assumptions.predicates.sets.ExtendedRealPredicate

Extended real predicate.

classsympy.assumptions.predicates.sets.HermitianPredicate

Hermitian predicate.

classsympy.assumptions.predicates.sets.ImaginaryPredicate

Imaginary number predicate.

classsympy.assumptions.predicates.sets.IntegerPredicate

Integer predicate.

classsympy.assumptions.predicates.sets.IrrationalPredicate

Irrational number predicate.

classsympy.assumptions.predicates.sets.NonIntegerPredicate

Non-integer extended real predicate.

classsympy.assumptions.predicates.sets.RationalPredicate

Rational number predicate.

classsympy.assumptions.predicates.sets.RealPredicate

Real number predicate.

classsympy.assumptions.predicates.sets.TranscendentalPredicate

Transcendental number predicate.

funcsympy.assumptions.refine.refine_Pow(expr, assumptions)

Handler for instances of Pow.

funcsympy.assumptions.refine.refine_abs(expr, assumptions)

Handler for the absolute value.

funcsympy.assumptions.refine.refine_atan2(expr, assumptions)

Handler for the atan2 function.

funcsympy.assumptions.refine.refine_exp(expr, assumptions)

Handler for exponential functions.

funcsympy.assumptions.refine.refine_im(expr, assumptions)

Handler for imaginary part.

funcsympy.assumptions.refine.refine_matrixelement(expr, assumptions)

Handler for symmetric part.

funcsympy.assumptions.refine.refine_re(expr, assumptions)

Handler for real part.

funcsympy.assumptions.refine.refine_sign(expr, assumptions)

Handler for sign.

funcsympy.assumptions.refine.refine_sin_cos(expr, assumptions)

Handler for sin and cos functions.

classsympy.assumptions.relation.binrel.BinaryRelation

Base class for all binary relational predicates.

classsympy.assumptions.relation.equality.EqualityPredicate

Binary predicate for $=$.

classsympy.assumptions.relation.equality.GreaterThanPredicate

Binary predicate for $>=$.

classsympy.assumptions.relation.equality.LessThanPredicate

Binary predicate for $<=$.

classsympy.assumptions.relation.equality.StrictGreaterThanPredicate

Binary predicate for $>$.

classsympy.assumptions.relation.equality.StrictLessThanPredicate

Binary predicate for $<$.

classsympy.assumptions.relation.equality.UnequalityPredicate

Binary predicate for $\neq$.

funcsympy.assumptions.satask.find_symbols(pred)

Find every :obj:`~.Symbol` in *pred*.

classsympy.assumptions.sathandlers.ClassFactRegistry

classsympy.calculus.accumulationbounds.AccumulationBounds

An accumulation bounds.

func

sympy.calculus.singularities.singularities(expression:Expr | complex, symbol:Symbol | Basic, domain:Set | None=None) -> set[Symbol]

Find singularities of a given function.

classsympy.categories.baseclasses.Category

An (abstract) category.

methodsympy.categories.baseclasses.Category.name()

Returns the name of this category.

classsympy.categories.baseclasses.CompositeMorphism

Represents a morphism which is a composition of other morphisms.

classsympy.categories.baseclasses.Diagram

Represents a diagram in a certain category.

methodsympy.categories.baseclasses.Diagram.premises()

Returns the premises of this diagram.

classsympy.categories.baseclasses.IdentityMorphism

Represents an identity morphism.

classsympy.categories.baseclasses.Morphism

The base class for any morphism in an abstract category.

methodsympy.categories.baseclasses.Morphism.codomain()

Returns the codomain of the morphism.

methodsympy.categories.baseclasses.Morphism.domain()

Returns the domain of the morphism.

classsympy.categories.baseclasses.NamedMorphism

Represents a morphism which has a name.

methodsympy.categories.baseclasses.NamedMorphism.name()

Returns the name of the morphism.

classsympy.categories.baseclasses.Object

The base class for any kind of object in an abstract category.

classsympy.codegen.approximations.SeriesApprox

Approximates functions by expanding them as a series.

classsympy.codegen.approximations.SumApprox

Approximates sum by neglecting small terms.

classsympy.codegen.ast.Assignment

Represents variable assignment for code generation.

classsympy.codegen.ast.AssignmentBase

Abstract base class for Assignment and AugmentedAssignment.

classsympy.codegen.ast.AugmentedAssignment

Base class for augmented assignments.

classsympy.codegen.ast.BreakToken

Represents 'break' in C/Python ('exit' in Fortran).

classsympy.codegen.ast.CodeBlock

Represents a block of code.

classsympy.codegen.ast.Comment

Represents a comment.

classsympy.codegen.ast.ComplexType

Represents a complex floating point number.

classsympy.codegen.ast.Element

Element in (a possibly N-dimensional) array.

classsympy.codegen.ast.FloatBaseType

Represents a floating point number type.

classsympy.codegen.ast.FloatType

Represents a floating point type with fixed bit width.

methodsympy.codegen.ast.FloatType.max()

Maximum value representable.

methodsympy.codegen.ast.FloatType.tiny()

The minimum positive normalized value.

classsympy.codegen.ast.For

Represents a 'for-loop' in the code.

classsympy.codegen.ast.FunctionCall

Represents a call to a function in the code.

classsympy.codegen.ast.FunctionDefinition

Represents a function definition in the code.

classsympy.codegen.ast.IntBaseType

Integer base type, contains no size information.

classsympy.codegen.ast.Pointer

Represents a pointer.

classsympy.codegen.ast.Print

Represents print command in the code.

classsympy.codegen.ast.QuotedString

Represents a string which should be printed with quotes.

classsympy.codegen.ast.Raise

Prints as 'raise ...' in Python, 'throw ...' in C++

classsympy.codegen.ast.Return

Represents a return command in the code.

classsympy.codegen.ast.Scope

Represents a scope in the code.

classsympy.codegen.ast.SignedIntType

Represents a signed integer type.

classsympy.codegen.ast.Stream

Represents a stream.

classsympy.codegen.ast.String

SymPy object representing a string.

classsympy.codegen.ast.Token

Base class for the AST types.

classsympy.codegen.ast.Type

Represents a type.

classsympy.codegen.ast.UnsignedIntType

Represents an unsigned integer type.

classsympy.codegen.ast.Variable

Represents a variable.

methodsympy.codegen.ast.Variable.deduced(symbol, value=None, attrs=Tuple(), cast_check=True)

Alt.

classsympy.codegen.ast.While

Represents a 'for-loop' in the code.

funcsympy.codegen.ast.aug_assign(lhs, op, rhs)

Create 'lhs op= rhs'.

classsympy.codegen.cfunctions.Cbrt

Represents the cube root function.

classsympy.codegen.cfunctions.Sqrt

Represents the square root function.

classsympy.codegen.cfunctions.exp2

Represents the exponential function with base two.

classsympy.codegen.cfunctions.expm1

Represents the exponential function minus one.

classsympy.codegen.cfunctions.fma

Represents "fused multiply add".

classsympy.codegen.cfunctions.hypot

Represents the hypotenuse function.

classsympy.codegen.cfunctions.log10

Represents the logarithm function with base ten.

classsympy.codegen.cfunctions.log1p

Represents the natural logarithm of a number plus one.

classsympy.codegen.cfunctions.log2

Represents the logarithm function with base two.

classsympy.codegen.cnodes.CommaOperator

Represents the comma operator in C

classsympy.codegen.cnodes.Label

Label for use with e.g.

classsympy.codegen.cnodes.goto

Represents goto in C

classsympy.codegen.cnodes.struct

Represents a struct in C

classsympy.codegen.cnodes.union

Represents a union in C

classsympy.codegen.cxxnodes.using

Represents a 'using' statement in C++

classsympy.codegen.fnodes.ArrayConstructor

Represents an array constructor.

classsympy.codegen.fnodes.Do

Represents a Do loop in in Fortran.

classsympy.codegen.fnodes.Extent

Represents a dimension extent.

classsympy.codegen.fnodes.FortranReturn

AST node explicitly mapped to a fortran "return".

classsympy.codegen.fnodes.ImpliedDoLoop

Represents an implied do loop in Fortran.

classsympy.codegen.fnodes.Module

Represents a module in Fortran.

classsympy.codegen.fnodes.Program

Represents a 'program' block in Fortran.

classsympy.codegen.fnodes.Subroutine

Represents a subroutine in Fortran.

classsympy.codegen.fnodes.SubroutineCall

Represents a call to a subroutine in Fortran.

classsympy.codegen.fnodes.cmplx

Fortran complex conversion function.

classsympy.codegen.fnodes.dsign

Fortran sign intrinsic for double precision arguments.

classsympy.codegen.fnodes.isign

Fortran sign intrinsic for integer arguments.

classsympy.codegen.fnodes.kind

Fortran kind function.

classsympy.codegen.fnodes.literal_dp

Fortran double precision real literal

classsympy.codegen.fnodes.literal_sp

Fortran single precision real literal

classsympy.codegen.fnodes.merge

Fortran merge function

classsympy.codegen.fnodes.use

Represents a use statement in Fortran.

classsympy.codegen.fnodes.use_rename

Represents a renaming in a use statement in Fortran.

classsympy.codegen.matrix_nodes.MatrixSolve

Represents an operation to solve a linear matrix equation.

classsympy.codegen.numpy_nodes.amax

Maximum value along an axis.

classsympy.codegen.numpy_nodes.amin

Minimum value along an axis.

classsympy.codegen.numpy_nodes.logaddexp

Logarithm of the sum of exponentiations of the inputs.

classsympy.codegen.numpy_nodes.maximum

Element-wise maximum of array elements.

classsympy.codegen.numpy_nodes.minimum

Element-wise minimum of array elements.

classsympy.codegen.pynodes.NumExprEvaluate

represents a call to :class:`numexpr`s :func:`evaluate`

classsympy.codegen.rewriting.Optimization

Abstract base class for rewriting optimization.

classsympy.codegen.rewriting.ReplaceOptim

Rewriting optimization calling replace on expressions.

funcsympy.codegen.rewriting.optimize(expr, optimizations)

Apply optimizations to an expression.

classsympy.codegen.scipy_nodes.cosm1

Minus one plus cosine of x, i.e.

classsympy.codegen.scipy_nodes.powm1

Minus one plus x to the power of y, i.e.

classsympy.combinatorics.free_groups.FreeGroup

Free group with finite or infinite number of generators.

methodsympy.combinatorics.free_groups.FreeGroup.is_abelian()

Returns if the group is Abelian.

methodsympy.combinatorics.free_groups.FreeGroup.order()

Return the order of the free group.

classsympy.combinatorics.free_groups.FreeGroupElement

Used to create elements of FreeGroup.

methodsympy.combinatorics.free_groups.FreeGroupElement.is_independent(word)

See Also ======== is_dependent

methodsympy.combinatorics.free_groups.FreeGroupElement.prod(words:Iterable[C]) -> C

Return the product of an iterable of words from the same free group.

classsympy.combinatorics.galois.S1TransitiveSubgroups

Names for the transitive subgroups of S1.

classsympy.combinatorics.galois.S2TransitiveSubgroups

Names for the transitive subgroups of S2.

classsympy.combinatorics.galois.S3TransitiveSubgroups

Names for the transitive subgroups of S3.

classsympy.combinatorics.galois.S4TransitiveSubgroups

Names for the transitive subgroups of S4.

classsympy.combinatorics.galois.S5TransitiveSubgroups

Names for the transitive subgroups of S5.

classsympy.combinatorics.galois.S6TransitiveSubgroups

Names for the transitive subgroups of S6.

funcsympy.combinatorics.generators.alternating(n:int) -> Iterator[Permutation]

Generates the alternating group of order n, An.

funcsympy.combinatorics.generators.cyclic(n:int) -> Iterator[Permutation]

Generates the cyclic group of order n, Cn.

funcsympy.combinatorics.generators.dihedral(n:int) -> Iterator[Permutation]

Generates the dihedral group of order 2n, Dn.

funcsympy.combinatorics.generators.rubik(n:int) -> list[Permutation]

Return permutations for an nxn Rubik's cube.

funcsympy.combinatorics.generators.symmetric(n:int) -> Iterator[Permutation]

Generates the symmetric group of order n, Sn.

funcsympy.combinatorics.graycode.bin_to_gray(bin_list:str) -> str

Convert from binary coding to gray coding.

funcsympy.combinatorics.graycode.get_subset_from_bitstring(super_set:list[T], bitstring:str) -> list[T]

Gets the subset defined by the bitstring.

funcsympy.combinatorics.graycode.gray_to_bin(bin_list:str) -> str

Convert from Gray coding to binary coding.

funcsympy.combinatorics.graycode.graycode_subsets(gray_code_set:list[T]) -> Iterator[list[T]]

Generates the subsets as enumerated by a Gray code.

funcsympy.combinatorics.graycode.random_bitstring(n:int) -> str

Generates a random bitlist of length n.

funcsympy.combinatorics.group_numbers.groups_count(n)

Number of groups of order `n`.

funcsympy.combinatorics.group_numbers.is_abelian_number(n) -> bool

Check whether `n` is an abelian number.

funcsympy.combinatorics.group_numbers.is_cyclic_number(n) -> bool

Check whether `n` is a cyclic number.

funcsympy.combinatorics.group_numbers.is_nilpotent_number(n) -> bool

Check whether `n` is a nilpotent number.

classsympy.combinatorics.homomorphisms.GroupHomomorphism

A class representing group homomorphisms.

methodsympy.combinatorics.homomorphisms.GroupHomomorphism.image()

Compute the image of `self`.

methodsympy.combinatorics.homomorphisms.GroupHomomorphism.kernel()

Compute the kernel of `self`.

classsympy.combinatorics.partitions.IntegerPartition

This class represents an integer partition.

methodsympy.combinatorics.partitions.IntegerPartition.conjugate()

Computes the conjugate partition of itself.

classsympy.combinatorics.partitions.Partition

This class represents an abstract partition.

methodsympy.combinatorics.partitions.Partition.rank()

Gets the rank of a partition.

classsympy.combinatorics.pc_groups.Collector

References ========== ..

methodsympy.combinatorics.pc_groups.Collector.depth(element)

Return the depth of a given element.

methodsympy.combinatorics.pc_groups.Collector.map_relation(w)

Return a conjugate relation.

methodsympy.combinatorics.pc_groups.Collector.pc_relators()

Return the polycyclic presentation.

classsympy.combinatorics.perm_groups.PermutationGroup

The class defining a Permutation group.

methodsympy.combinatorics.perm_groups.PermutationGroup.derived_subgroup()

Compute the derived subgroup.

methodsympy.combinatorics.perm_groups.PermutationGroup.is_abelian()

Test if the group is Abelian.

methodsympy.combinatorics.perm_groups.PermutationGroup.is_nilpotent()

Test if the group is nilpotent.

methodsympy.combinatorics.perm_groups.PermutationGroup.is_solvable()

Test if the group is solvable.

methodsympy.combinatorics.perm_groups.PermutationGroup.random(af=False)

Return a random group element

methodsympy.combinatorics.perm_groups.PermutationGroup.schreier_sims()

Schreier-Sims algorithm.

classsympy.combinatorics.perm_groups.SymmetricPermutationGroup

The class defining the lazy form of SymmetricGroup.

classsympy.combinatorics.permutations.AppliedPermutation

A permutation applied to a symbolic variable.

classsympy.combinatorics.polyhedron.Polyhedron

Represents the polyhedral symmetry group (PSG).

methodsympy.combinatorics.polyhedron.Polyhedron.array_form()

Return the indices of the corners.

methodsympy.combinatorics.polyhedron.Polyhedron.corners()

Get the corners of the Polyhedron.

methodsympy.combinatorics.polyhedron.Polyhedron.faces()

Get the faces of the Polyhedron.

classsympy.combinatorics.rewritingsystem.RewritingSystem

A class implementing rewriting systems for `FpGroup`s.

classsympy.combinatorics.rewritingsystem_fsm.State

A representation of a state managed by a ``StateMachine``.

classsympy.combinatorics.subsets.Subset

Represents a basic subset object.

methodsympy.combinatorics.subsets.Subset.iterate_binary(k)

This is a helper function.

methodsympy.combinatorics.subsets.Subset.rank_binary()

Computes the binary ordered rank.

methodsympy.combinatorics.subsets.Subset.size()

Gets the size of the subset.

methodsympy.combinatorics.subsets.Subset.superset()

Gets the superset of the subset.

methodsympy.combinatorics.subsets.Subset.superset_size()

Returns the size of the superset.

funcsympy.combinatorics.tensor_can.bsgs_direct_product(base1, gens1, base2, gens2, signed=True)

Direct product of two BSGS.

classsympy.concrete.expr_with_intlimits.ExprWithIntLimits

Superclass for Product and Sum.

classsympy.concrete.expr_with_intlimits.ReorderError

Exception raised when trying to reorder dependent limits.

classsympy.concrete.expr_with_limits.AddWithLimits

Represents unevaluated oriented additions.

classsympy.concrete.products.Product

Represents unevaluated products.

funcsympy.concrete.products.product(*args, **kwargs)

Compute the product.

classsympy.concrete.summations.Sum

Represents unevaluated summation.

methodsympy.concrete.summations.Sum.is_convergent()

Checks for the convergence of a Sum.

classsympy.core._print_helpers.Printable

The default implementation of printing for SymPy classes.

classsympy.core.add.Add

Expression representing addition operation for algebraic group.

methodsympy.core.add.Add.as_coeff_Add(rational=False, deps=None) -> tuple[Number, Expr]

Efficiently extract the coefficient of a summation.

methodsympy.core.add.Add.as_real_imag(deep=True, **hints)

Return a tuple representing a complex number.

methodsympy.core.add.Add.as_two_terms()

Return head and tail of self.

funcsympy.core.assumptions.assumptions(expr, _check=None)

return the T/F assumptions of ``expr``

classsympy.core.basic.Atom

A parent class for atomic things.

classsympy.core.basic.Basic

Base class for all SymPy objects.

methodsympy.core.basic.Basic.args() -> tuple[Basic, ...]

Returns a tuple of arguments of 'self'.

methodsympy.core.basic.Basic.assumptions0()

Return object `type` assumptions.

methodsympy.core.basic.Basic.class_key() -> tuple[int, int, str]

Nice order of classes.

methodsympy.core.basic.Basic.count(query)

Count the number of matching subexpressions.

methodsympy.core.basic.Basic.free_symbols() -> set[Basic]

Return from the atoms of self those which are free symbols.

methodsympy.core.basic.Basic.fromiter(args, **assumptions)

Create a new object from an iterable.

methodsympy.core.basic.Basic.func()

The top-level function in an expression.

methodsympy.core.basic.Basic.has(*patterns)

Test whether any subexpression matches any of the patterns.

methodsympy.core.basic.Basic.match(pattern, old=False)

Pattern matching.

methodsympy.core.basic.Basic.refine(assumption=True)

See the refine function in sympy.assumptions

methodsympy.core.basic.Basic.replace(query, value, map=False, simultaneous=True, exact=None) -> Basic

Replace matching subexpressions of ``self`` with ``value``.

methodsympy.core.basic.Basic.rewrite(*deep=True, *args, **hints)

Rewrite *self* using a defined rule.

methodsympy.core.basic.Basic.simplify(**kwargs) -> Basic

See the simplify function in sympy.simplify

methodsympy.core.basic.Basic.sort_key(order=None)

Return a sort key.

funcsympy.core.basic.Basic.walk(rv, F)

Apply ``F`` to args and then to result.

methodsympy.core.basic.Basic.xreplace(rule)

Replace occurrences of objects within the expression.

funcsympy.core.cache.cached_property(func)

Decorator to cache property method

funcsympy.core.cache.lazy_function(module:str, name:str) -> Callable

Create a lazy proxy for a function in a module.

classsympy.core.containers.Dict

Wrapper around the builtin dict object.

methodsympy.core.containers.Dict.get(key, default=None)

Returns the value for key if the key is in the dictionary.

methodsympy.core.containers.Dict.keys()

Returns the list of the dict's keys.

methodsympy.core.containers.Dict.values()

Returns the list of the dict's values.

classsympy.core.containers.Tuple

Wrapper around the builtin tuple object.

methodsympy.core.containers.Tuple.kind()

The kind of a Tuple instance.

methodsympy.core.containers.Tuple.tuple_count(value) -> int

Return number of occurrences of value.

classsympy.core.core.Registry

Base class for registry objects.

classsympy.core.coreerrors.BaseCoreError

Base class for core related exceptions.

classsympy.core.coreerrors.NonCommutativeExpression

Raised when expression didn't have commutative property.

funcsympy.core.decorators.sympify_method_args(cls:type[T1]) -> type[T1]

Decorator for a class with methods that sympify arguments.

classsympy.core.evalf.EvalfMixin

Mixin class adding evalf capability.

funcsympy.core.evalf.N(x, n=15, **options)

Calls x.evalf(n, \*\*options).

funcsympy.core.evalf.add_terms(terms:list, prec:int, target_prec:int) -> tuple[MPF_TUP | SCALED_ZERO_TUP | None, int | None]

Helper for evalf_add.

funcsympy.core.evalf.chop_parts(value:TMP_RES, prec:int) -> TMP_RES

Chop off tiny real or complex parts.

funcsympy.core.evalf.evalf(x:Expr, prec:int, options:OPT_DICT) -> TMP_RES

Evaluate the ``Expr`` instance, ``x`` to a binary precision of ``prec``.

funcsympy.core.evalf.evalf_subs(prec:int, subs:dict) -> dict

Change all Float entries in `subs` to have precision prec.

funcsympy.core.evalf.evalf_trig(v:Expr, prec:int, options:OPT_DICT) -> TMP_RES

This function handles sin , cos and tan of complex arguments.

funcsympy.core.evalf.fastlog(x:MPF_TUP | None) -> int | Any

Fast approximation of log2(x) for an mpf value tuple x.

funcsympy.core.evalf.get_complex_part(expr:Expr, no:int, prec:int, options:OPT_DICT) -> TMP_RES

no = 0 for real part, no = 1 for imaginary part

funcsympy.core.evalf.is_int_reim(x)

Check for integer or integer + I*integer.

classsympy.core.expr.AtomicExpr

A parent class for object which are both atoms and Exprs.

classsympy.core.expr.Expr

Base class for algebraic expressions.

methodsympy.core.expr.Expr.apart(x=None, **args)

See the apart function in sympy.polys

methodsympy.core.expr.Expr.as_coeff_Add(rational=False) -> tuple['Number', Expr]

Efficiently extract the coefficient of a summation.

methodsympy.core.expr.Expr.as_coeff_exponent(x) -> tuple[Expr, Expr]

``c*x**e -> c,e`` where x can be any symbolic expression.

methodsympy.core.expr.Expr.as_coeff_mul(*deps, **kwargs) -> tuple[Expr, tuple[Expr, ...]]

Return the tuple (c, args) where self is written as a Mul, ``m``.

methodsympy.core.expr.Expr.as_coefficient(expr:Expr) -> Expr | None

Extracts symbolic coefficient at the given expression.

methodsympy.core.expr.Expr.as_expr(*gens)

Convert a polynomial to a SymPy expression.

methodsympy.core.expr.Expr.as_numer_denom() -> tuple[Expr, Expr]

Return the numerator and the denominator of an expression.

methodsympy.core.expr.Expr.as_ordered_terms(order=None, data:Literal[False]=False) -> list[Expr]

Transform an expression to an ordered list of terms.

methodsympy.core.expr.Expr.as_terms() -> tuple[list[tuple[Expr, Any]], list[Expr]]

Transform an expression to a list of terms.

methodsympy.core.expr.Expr.aseries(x=None, n=6, bound=0, hir=False)

Asymptotic Series expansion of self.

methodsympy.core.expr.Expr.cancel(*gens, **args)

See the cancel function in sympy.polys

methodsympy.core.expr.Expr.combsimp()

See the combsimp function in sympy.simplify

methodsympy.core.expr.Expr.conjugate()

Returns the complex conjugate of 'self'.

method

sympy.core.expr.Expr.expand(deep=True, modulus=None, power_base=True, power_exp=True, mul=True, log=True, multinomial=True, basic=True, **hints) -> Expr

Expand an expression using hints.

funcsympy.core.expr.Expr.find(l, sub, first=True)

Find where list sub appears in list l.

methodsympy.core.expr.Expr.gammasimp()

See the gammasimp function in sympy.simplify

methodsympy.core.expr.Expr.getO() -> Expr | None

Returns the additive O(..) symbol if there is one, else None.

methodsympy.core.expr.Expr.getn()

Returns the order of the expression.

methodsympy.core.expr.Expr.limit(x, xlim, dir='+')

Compute limit x->xlim.

methodsympy.core.expr.Expr.normal()

Return the expression as a fraction.

methodsympy.core.expr.Expr.powsimp(*args, **kwargs)

See the powsimp function in sympy.simplify

methodsympy.core.expr.Expr.radsimp(**kwargs)

See the radsimp function in sympy.simplify

methodsympy.core.expr.Expr.ratsimp()

See the ratsimp function in sympy.simplify

methodsympy.core.expr.Expr.removeO() -> Expr

Removes the additive O(..) symbol if there is one

methodsympy.core.expr.Expr.round(n=None)

Return x rounded to the given decimal place.

methodsympy.core.expr.Expr.taylor_term(n, x, *previous_terms)

General method for the taylor term.

methodsympy.core.expr.Expr.together(*args, **kwargs)

See the together function in sympy.polys

methodsympy.core.expr.Expr.trigsimp(**args)

See the trigsimp function in sympy.simplify

funcsympy.core.expr.Expr.yield_lseries(s)

Return terms of lseries one at a time.

classsympy.core.expr.UnevaluatedExpr

Expression that is not evaluated unless released.

classsympy.core.exprtools.Factors

Efficient representation of ``f_1*f_2*...*f_n``.

methodsympy.core.exprtools.Factors.as_expr()

Return the underlying expression.

methodsympy.core.exprtools.Factors.gcd(other)

Return Factors of ``gcd(self, other)``.

methodsympy.core.exprtools.Factors.mul(other)

Return Factors of ``self * other``.

methodsympy.core.exprtools.Factors.quo(other)

Return numerator Factor of ``self / other``.

classsympy.core.exprtools.Term

Efficient representation of ``coeff*(numer/denom)``.

funcsympy.core.exprtools.decompose_power(expr:Expr) -> tuple[Expr, int]

Decompose power into symbolic base and integer exponent.

methodsympy.core.facts.Prover.process_rule(a, b)

process a -> b rule

classsympy.core.facts.TautologyDetected

(internal) Prover uses it for reporting detected tautology

classsympy.core.function.Application

Base class for applied functions.

classsympy.core.function.BadSignatureError

Raised when a Lambda is created with an invalid signature

classsympy.core.function.DefinedFunction

Base class for defined functions like ``sin``, ``cos``, ...

classsympy.core.function.Derivative

Carries out differentiation of the given expression with respect to symbols.

classsympy.core.function.Function

Base class for applied mathematical functions.

classsympy.core.function.FunctionClass

Base class for function classes.

methodsympy.core.function.Lambda.expr()

The return value of the function

classsympy.core.function.Subs

Represents unevaluated substitutions of an expression.

methodsympy.core.function.Subs.variables()

The variables to be evaluated

classsympy.core.function.UndefSageHelper

Helper to facilitate Sage conversion.

classsympy.core.function.UndefinedFunction

The (meta)class of undefined functions.

funcsympy.core.function.diff(f, *symbols, **kwargs)

Differentiate f with respect to symbols.

funcsympy.core.function.expand_mul(expr, deep=True)

Wrapper around expand that only uses the mul hint.

funcsympy.core.intfunc.igcd(*args)

Computes nonnegative integer greatest common divisor.

funcsympy.core.intfunc.ilcm(*args)

Computes integer least common multiple.

classsympy.core.kind.Kind

Base class for kinds.

classsympy.core.kind.KindMeta

Metaclass for ``Kind``.

classsympy.core.logic.Logic

Logical expression

funcsympy.core.logic.fuzzy_and(args)

Return True (all True), False (any False) or None.

funcsympy.core.logic.fuzzy_bool(x)

Return True, False or None according to x.

funcsympy.core.logic.fuzzy_not(v:bool | None) -> bool | None

Not in fuzzy logic Return None if `v` is None else `not v`.

funcsympy.core.logic.fuzzy_or(args)

Or in fuzzy logic.

classsympy.core.mod.Mod

Represents a modulo operation on symbolic expressions.

classsympy.core.mul.Mul

Expression representing multiplication operation for algebraic field.

methodsympy.core.mul.Mul.as_two_terms()

Return head and tail of self.

funcsympy.core.mul.prod(a, start=1)

Return product of elements of a.

classsympy.core.numbers.AlgebraicNumber

Class for representing algebraic numbers in SymPy.

methodsympy.core.numbers.AlgebraicNumber.as_poly(x=None)

Create a Poly instance from ``self``.

methodsympy.core.numbers.AlgebraicNumber.is_aliased()

Returns ``True`` if ``alias`` was set.

classsympy.core.numbers.Catalan

Catalan's constant.

classsympy.core.numbers.ComplexInfinity

Complex infinity.

classsympy.core.numbers.EulerGamma

The Euler-Mascheroni constant.

classsympy.core.numbers.Exp1

The `e` constant.

classsympy.core.numbers.Float

Represent a floating-point number of arbitrary precision.

classsympy.core.numbers.GoldenRatio

The golden ratio, `\phi`.

classsympy.core.numbers.Half

The rational number 1/2.

classsympy.core.numbers.ImaginaryUnit

The imaginary unit, `i = \sqrt{-1}`.

classsympy.core.numbers.Infinity

Positive infinite quantity.

classsympy.core.numbers.Integer

Represents integer numbers of any size.

classsympy.core.numbers.NaN

Not a Number.

classsympy.core.numbers.NegativeInfinity

Negative infinite quantity.

classsympy.core.numbers.NegativeOne

The number negative one.

classsympy.core.numbers.Number

Represents atomic numbers in SymPy.

methodsympy.core.numbers.Number.gcd(other)

Compute GCD of `self` and `other`.

methodsympy.core.numbers.Number.lcm(other)

Compute LCM of `self` and `other`.

この情報について

掲載しているシグネチャは sympy/sympy の公開ソースコードを Python の ast モジュールで静的解析し、引数名・デフォルト値・型注釈・戻り値型をそのまま抽出したものです。実装コードは保存していません。詳しくは仕組みの解説をご覧ください。

収録ライブラリ一覧（全 805 件）へ戻る