From 32416f59dea895ccdceb877b9fb25e889d4f150e Mon Sep 17 00:00:00 2001 From: anutosh491 <87052487+anutosh491@users.noreply.github.com> Date: Mon, 26 Aug 2024 18:17:59 +0000 Subject: [PATCH] =?UTF-8?q?Deploying=20to=20gh-pages=20from=20@=20sympy/sy?= =?UTF-8?q?mpy@7fafce93a7abb985e98cd0fd62e0500dfd8407fd=20=F0=9F=9A=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../matrices-10.pdf | Bin 287793 -> 287793 bytes .../beam-2.pdf | Bin 10738 -> 10738 bytes .../beam-23.pdf | Bin 13812 -> 13812 bytes .../plotting-2.pdf | Bin 10420 -> 10420 bytes .../plotting-32_01.pdf | Bin 9491 -> 9491 bytes .../control_plots-4.pdf | Bin 16070 -> 16070 bytes .../beam_problems-13_00.pdf | Bin 11391 -> 11391 bytes .../beam-1.pdf | Bin 407297 -> 407297 bytes .../beam-5.pdf | Bin 14151 -> 14151 bytes .../beam-21.pdf | Bin 13017 -> 13017 bytes .../plotting-4.pdf | Bin 8949 -> 8949 bytes .../plotting-17.pdf | Bin 539955 -> 539955 bytes .../plotting-6.pdf | Bin 9491 -> 9491 bytes .../control_plots-5.pdf | Bin 16229 -> 16229 bytes .../matrices-24.pdf | Bin 271973 -> 271973 bytes .../matrices-25.pdf | Bin 287793 -> 287793 bytes .../plotting-16.pdf | Bin 529288 -> 529288 bytes .../plotting-26.hires.png | Bin 30783 -> 30768 bytes .../beam_problems-14.pdf | Bin 16999 -> 16999 bytes .../beam-8.pdf | Bin 10148 -> 10148 bytes .../matrices-22.pdf | Bin 245620 -> 245620 bytes .../matrices-4.pdf | Bin 271973 -> 271973 bytes .../plotting-32_00.pdf | Bin 9295 -> 9295 bytes .../beam_problems-18.pdf | Bin 10501 -> 10501 bytes .../plotting-26.pdf | Bin 128984 -> 129271 bytes .../plotting-1.pdf | Bin 10388 -> 10388 bytes .../plotting-29.hires.png | Bin 19488 -> 19470 bytes .../control_plots-2.pdf | Bin 19512 -> 19512 bytes .../generate_plots_q3_3.pdf | Bin 15852 -> 15852 bytes .../control_plots-1.pdf | Bin 15532 -> 15532 bytes .../matrices-8.pdf | Bin 288225 -> 288225 bytes .../plotting-19.pdf | Bin 9515 -> 9515 bytes .../matrices-17.pdf | Bin 245620 -> 245620 bytes .../matrices-18.pdf | Bin 288225 -> 288225 bytes .../plotting-33.pdf | Bin 11049 -> 11049 bytes .../beam-20.pdf | Bin 16340 -> 16340 bytes .../plotting-25.hires.png | Bin 32745 -> 32762 bytes .../biomechanics-11.pdf | Bin 11956 -> 11956 bytes .../biomechanical-model-example-35.pdf | Bin 21668 -> 21668 bytes .../beam_problems-13_01.pdf | Bin 11920 -> 11920 bytes .../plotting-7.pdf | Bin 10318 -> 10318 bytes .../plotting-20.pdf | Bin 9752 -> 9752 bytes .../plotting-28.pdf | Bin 12886 -> 12886 bytes .../plotting-15.pdf | Bin 269841 -> 269841 bytes .../generate_plots_q3_5_1.pdf | Bin 16617 -> 16617 bytes .../matrices-13.pdf | Bin 288225 -> 288225 bytes .../generate_plots_q5.pdf | Bin 16469 -> 16469 bytes .../plotting-27.pdf | Bin 14716 -> 14716 bytes .../plotting-30.png | Bin 8670 -> 8719 bytes .../biomechanics-12.pdf | Bin 13177 -> 13177 bytes .../matrices-2.pdf | Bin 245620 -> 245620 bytes .../plotting-25.png | Bin 10118 -> 10133 bytes .../generate_plots_q3_4.pdf | Bin 16190 -> 16190 bytes .../plotting-11.pdf | Bin 8674 -> 8674 bytes .../matrices-6.pdf | Bin 287793 -> 287793 bytes .../matrices-19.pdf | Bin 271973 -> 271973 bytes .../plotting-26.png | Bin 9356 -> 9341 bytes .../matrices-21.pdf | Bin 287793 -> 287793 bytes .../plotting-12.pdf | Bin 7938 -> 7938 bytes .../matrices-12.pdf | Bin 245620 -> 245620 bytes .../beam-19.pdf | Bin 12951 -> 12951 bytes .../beam_problems-11_00.pdf | Bin 9613 -> 9613 bytes .../matrices-15.pdf | Bin 287793 -> 287793 bytes .../plotting-29.pdf | Bin 18566 -> 18323 bytes .../plotting-13.pdf | Bin 7942 -> 7942 bytes .../beam_problems-16.pdf | Bin 9416 -> 9416 bytes .../biomechanics-14.pdf | Bin 10590 -> 10590 bytes .../plotting-24.png | Bin 8382 -> 8359 bytes .../solve-ode-1.pdf | Bin 12674 -> 12674 bytes .../beam-4.pdf | Bin 9978 -> 9978 bytes .../plotting-10.pdf | Bin 10927 -> 10927 bytes .../biomechanics-34.pdf | Bin 21705 -> 21705 bytes .../plotting-35.pdf | Bin 268827 -> 268827 bytes .../matrices-16.pdf | Bin 287793 -> 287793 bytes .../plotting-30.pdf | Bin 26349 -> 27198 bytes .../beam-3.pdf | Bin 12556 -> 12556 bytes .../matrices-20.pdf | Bin 287793 -> 287793 bytes .../matrices-11.pdf | Bin 287793 -> 287793 bytes .../plotting-32_02.pdf | Bin 8842 -> 8842 bytes .../plotting-34.pdf | Bin 266941 -> 266941 bytes .../beam-18.pdf | Bin 12677 -> 12677 bytes .../generate_plots_q3_5_2.pdf | Bin 16617 -> 16617 bytes .../plotting-9.pdf | Bin 8486 -> 8486 bytes .../beam_problems-11_01.pdf | Bin 9823 -> 9823 bytes .../biomechanical-model-example-38.pdf | Bin 25373 -> 25373 bytes .../control_plots-3.pdf | Bin 14482 -> 14482 bytes .../matrices-9.pdf | Bin 271973 -> 271973 bytes .../plotting-22.pdf | Bin 217183 -> 217183 bytes .../plotting-29.png | Bin 6886 -> 6896 bytes .../beam-22.pdf | Bin 15304 -> 15304 bytes .../plotting-30.hires.png | Bin 25718 -> 25693 bytes .../matrices-14.pdf | Bin 271973 -> 271973 bytes .../beam-7.pdf | Bin 18085 -> 18085 bytes .../matrices-7.pdf | Bin 245620 -> 245620 bytes .../beam-6.pdf | Bin 9452 -> 9452 bytes .../plotting-32_03.pdf | Bin 269841 -> 269841 bytes .../matrices-1.pdf | Bin 287793 -> 287793 bytes .../plotting-24.hires.png | Bin 26952 -> 26954 bytes .../plotting-5.pdf | Bin 9295 -> 9295 bytes .../matrices-3.pdf | Bin 288225 -> 288225 bytes .../plotting-25.pdf | Bin 39808 -> 39848 bytes .../matrices-5.pdf | Bin 287793 -> 287793 bytes .../beam-9.pdf | Bin 11821 -> 11821 bytes .../matrices-23.pdf | Bin 288225 -> 288225 bytes .../fourier-1.pdf | Bin 15168 -> 15168 bytes .../fourier-2.pdf | Bin 23873 -> 23873 bytes .../beam-10.pdf | Bin 11835 -> 11835 bytes .../plotting-24.pdf | Bin 32005 -> 31913 bytes .../biomechanics-13.pdf | Bin 12383 -> 12383 bytes .../truss-1.pdf | Bin 3366 -> 3366 bytes .../plotting-31_01.pdf | Bin 20227 -> 20225 bytes .../plotting-31_00.pdf | Bin 20520 -> 20535 bytes dev/_images/plotting-24.png | Bin 8382 -> 8359 bytes dev/_images/plotting-25.png | Bin 10118 -> 10133 bytes dev/_images/plotting-26.png | Bin 9356 -> 9341 bytes dev/_images/plotting-29.png | Bin 6886 -> 6896 bytes dev/_images/plotting-30.png | Bin 8670 -> 8719 bytes dev/explanation/gotchas.html | 2 +- dev/modules/algebras.html | 66 +- dev/modules/assumptions/ask.html | 8 +- dev/modules/assumptions/assume.html | 18 +- dev/modules/assumptions/index.html | 12 +- dev/modules/assumptions/predicates.html | 84 +- dev/modules/assumptions/refine.html | 18 +- dev/modules/calculus/index.html | 40 +- dev/modules/categories.html | 36 +- dev/modules/codegen.html | 234 ++-- dev/modules/combinatorics/galois.html | 42 +- dev/modules/combinatorics/graycode.html | 20 +- .../combinatorics/group_constructs.html | 2 +- dev/modules/combinatorics/group_numbers.html | 8 +- dev/modules/combinatorics/named_groups.html | 10 +- dev/modules/combinatorics/partitions.html | 26 +- dev/modules/combinatorics/perm_groups.html | 134 +- dev/modules/combinatorics/permutations.html | 98 +- dev/modules/combinatorics/polyhedron.html | 6 +- dev/modules/combinatorics/prufer.html | 16 +- dev/modules/combinatorics/subsets.html | 30 +- dev/modules/combinatorics/tensor_can.html | 8 +- dev/modules/combinatorics/testutil.html | 10 +- dev/modules/combinatorics/util.html | 16 +- dev/modules/concrete.html | 38 +- dev/modules/core.html | 500 +++---- dev/modules/crypto.html | 102 +- dev/modules/diffgeom.html | 78 +- dev/modules/discrete.html | 30 +- dev/modules/functions/combinatorial.html | 66 +- dev/modules/functions/elementary.html | 186 +-- dev/modules/functions/index.html | 6 +- dev/modules/functions/special.html | 200 +-- dev/modules/geometry/curves.html | 12 +- dev/modules/geometry/ellipses.html | 48 +- dev/modules/geometry/entities.html | 18 +- dev/modules/geometry/lines.html | 90 +- dev/modules/geometry/plane.html | 36 +- dev/modules/geometry/points.html | 54 +- dev/modules/geometry/polygons.html | 52 +- dev/modules/geometry/utils.html | 10 +- dev/modules/holonomic/convert.html | 6 +- dev/modules/holonomic/internal.html | 4 +- dev/modules/holonomic/operations.html | 18 +- dev/modules/holonomic/represent.html | 10 +- dev/modules/integrals/g-functions.html | 78 +- dev/modules/integrals/integrals.html | 122 +- dev/modules/interactive.html | 14 +- dev/modules/liealgebras/index.html | 164 +-- dev/modules/logic.html | 90 +- dev/modules/matrices/dense.html | 22 +- dev/modules/matrices/expressions.html | 64 +- dev/modules/matrices/immutablematrices.html | 4 +- dev/modules/matrices/kind.html | 2 +- dev/modules/matrices/matrices.html | 368 +++--- dev/modules/matrices/normalforms.html | 4 +- dev/modules/matrices/sparse.html | 6 +- dev/modules/matrices/sparsetools.html | 6 +- dev/modules/ntheory.html | 202 +-- dev/modules/parsing.html | 58 +- .../physics/biomechanics/api/activation.html | 18 +- .../physics/biomechanics/api/curve.html | 86 +- .../biomechanics/api/musculotendon.html | 12 +- .../physics/continuum_mechanics/beam.html | 110 +- .../physics/continuum_mechanics/cable.html | 18 +- .../physics/continuum_mechanics/truss.html | 26 +- .../physics/control/control_plots.html | 26 +- dev/modules/physics/control/lti.html | 96 +- dev/modules/physics/hep/index.html | 8 +- dev/modules/physics/hydrogen.html | 8 +- dev/modules/physics/matrices.html | 8 +- .../physics/mechanics/api/actuator.html | 22 +- .../mechanics/api/deprecated_classes.html | 30 +- .../physics/mechanics/api/expr_manip.html | 4 +- dev/modules/physics/mechanics/api/joint.html | 14 +- .../physics/mechanics/api/kane_lagrange.html | 24 +- .../physics/mechanics/api/linearize.html | 6 +- .../physics/mechanics/api/part_bod.html | 46 +- .../physics/mechanics/api/pathway.html | 16 +- dev/modules/physics/mechanics/api/system.html | 44 +- .../mechanics/api/wrapping_geometry.html | 24 +- dev/modules/physics/optics/gaussopt.html | 32 +- dev/modules/physics/optics/medium.html | 2 +- dev/modules/physics/optics/polarization.html | 22 +- dev/modules/physics/optics/utils.html | 20 +- dev/modules/physics/optics/waves.html | 2 +- dev/modules/physics/paulialgebra.html | 2 +- dev/modules/physics/qho_1d.html | 6 +- .../physics/quantum/anticommutator.html | 4 +- dev/modules/physics/quantum/cartesian.html | 22 +- dev/modules/physics/quantum/cg.html | 10 +- dev/modules/physics/quantum/circuitplot.html | 26 +- dev/modules/physics/quantum/commutator.html | 4 +- dev/modules/physics/quantum/constants.html | 2 +- dev/modules/physics/quantum/dagger.html | 2 +- dev/modules/physics/quantum/gate.html | 68 +- dev/modules/physics/quantum/grover.html | 10 +- dev/modules/physics/quantum/hilbert.html | 18 +- dev/modules/physics/quantum/innerproduct.html | 2 +- dev/modules/physics/quantum/operator.html | 12 +- dev/modules/physics/quantum/operatorset.html | 4 +- dev/modules/physics/quantum/piab.html | 6 +- dev/modules/physics/quantum/qapply.html | 2 +- dev/modules/physics/quantum/qft.html | 12 +- dev/modules/physics/quantum/qubit.html | 22 +- dev/modules/physics/quantum/represent.html | 12 +- dev/modules/physics/quantum/shor.html | 6 +- dev/modules/physics/quantum/spin.html | 40 +- dev/modules/physics/quantum/state.html | 32 +- .../physics/quantum/tensorproduct.html | 4 +- dev/modules/physics/secondquant.html | 106 +- dev/modules/physics/sho.html | 4 +- dev/modules/physics/units/dimensions.html | 14 +- dev/modules/physics/units/prefixes.html | 2 +- dev/modules/physics/units/quantities.html | 8 +- dev/modules/physics/units/unitsystem.html | 6 +- dev/modules/physics/vector/api/classes.html | 92 +- .../physics/vector/api/fieldfunctions.html | 14 +- dev/modules/physics/vector/api/functions.html | 12 +- .../physics/vector/api/kinematics.html | 32 +- dev/modules/physics/vector/api/printing.html | 8 +- dev/modules/physics/wigner.html | 20 +- dev/modules/plotting.html | 72 +- dev/modules/polys/agca.html | 180 +-- dev/modules/polys/domainmatrix.html | 492 +++---- dev/modules/polys/domainsref.html | 1156 ++++++++--------- dev/modules/polys/internals.html | 600 ++++----- dev/modules/polys/numberfields.html | 194 +-- dev/modules/polys/reference.html | 530 ++++---- dev/modules/polys/ringseries.html | 70 +- dev/modules/polys/solvers.html | 10 +- dev/modules/printing.html | 212 +-- dev/modules/rewriting.html | 2 +- dev/modules/series/formal.html | 44 +- dev/modules/series/fourier.html | 16 +- dev/modules/series/limitseq.html | 6 +- dev/modules/series/sequences.html | 32 +- dev/modules/series/series.html | 50 +- dev/modules/sets.html | 110 +- dev/modules/simplify/fu.html | 50 +- dev/modules/simplify/simplify.html | 64 +- dev/modules/solvers/diophantine.html | 102 +- dev/modules/solvers/inequalities.html | 16 +- dev/modules/solvers/ode.html | 158 +-- dev/modules/solvers/pde.html | 18 +- dev/modules/solvers/solvers.html | 36 +- dev/modules/solvers/solveset.html | 30 +- dev/modules/stats.html | 292 ++--- dev/modules/tensor/array.html | 18 +- dev/modules/tensor/array_expressions.html | 8 +- dev/modules/tensor/index_methods.html | 4 +- dev/modules/tensor/indexed.html | 6 +- dev/modules/tensor/tensor.html | 72 +- dev/modules/tensor/toperators.html | 2 +- dev/modules/testing/pytest.html | 12 +- dev/modules/testing/runtests.html | 36 +- dev/modules/utilities/autowrap.html | 20 +- dev/modules/utilities/codegen.html | 60 +- dev/modules/utilities/decorator.html | 18 +- dev/modules/utilities/enumerative.html | 18 +- dev/modules/utilities/exceptions.html | 6 +- dev/modules/utilities/iterables.html | 110 +- dev/modules/utilities/lambdify.html | 6 +- dev/modules/utilities/memoization.html | 4 +- dev/modules/utilities/misc.html | 24 +- dev/modules/utilities/source.html | 4 +- dev/modules/utilities/timeutils.html | 2 +- dev/modules/vector/api/classes.html | 72 +- dev/modules/vector/api/orienterclasses.html | 22 +- dev/modules/vector/api/vectorfunctions.html | 20 +- 287 files changed, 5084 insertions(+), 5084 deletions(-) diff --git a/dev/_downloads/0130acc9674ca6615e762dac32f6f525/matrices-10.pdf b/dev/_downloads/0130acc9674ca6615e762dac32f6f525/matrices-10.pdf index e201b9a943afbbe618c7f414504133ef1b71457f..cf3b54de083a947954371c17c885dcba1022ad1c 100644 GIT binary patch delta 29 kcmdmZLU7{=!G;#b7N!>FEi6KbtQH2w24>sE6IrB~0iOQ|r~m)} delta 29 kcmdmZLU7{=!G;#b7N!>FEi6Kbtj0#h2FBaP6IrB~0iMSQq5uE@ diff --git a/dev/_downloads/0249fb66c2fcb06b78bd6a84135be88a/beam-2.pdf b/dev/_downloads/0249fb66c2fcb06b78bd6a84135be88a/beam-2.pdf index 54233baaa23e441ad3739fc6df03274d1a28b174..ab7f9921208a4ea9c06826068a85a783304c0aca 100644 GIT binary patch delta 18 Zcmewq{3&=ts~W3?fw8I4<}S4iW&lh12D<rfvJJvW@V)hOaM3@1(*N; delta 18 ZcmbR2HQ8%}oD!?Ck*R^fW@V)hOaM3d1(W~) diff --git a/dev/_downloads/0680199b4e61bc189fceb4418aa72812/control_plots-4.pdf b/dev/_downloads/0680199b4e61bc189fceb4418aa72812/control_plots-4.pdf index f88048a9bce528f1048584cabdf83af09385448e..34ca9290fe8607fa2d9aa8763bb688993f760dd6 100644 GIT binary patch delta 18 ZcmX?Bd#rYYjuoqgfr+8{W<#r~EC5Fd23-IE delta 18 ZcmX?Bd#rYYjuor1k%^(nW<#r~EC5E=23G(8 diff --git a/dev/_downloads/077b659bec1d5c2fd531dbd0f7e15f0f/beam_problems-13_00.pdf b/dev/_downloads/077b659bec1d5c2fd531dbd0f7e15f0f/beam_problems-13_00.pdf index c2eb7a157fd241c0de128fecc5b4afce8b33a21e..d3f2efc1d92e3e62486e298b96c25451507e1ae8 100644 GIT binary patch delta 18 Zcmew#@jqgNswS(2fr)|TW-ZN7W&lVD1{DAR delta 18 Zcmew#@jqgNswS(kk%@u%W-ZN7W&lUs1`q%M diff --git a/dev/_downloads/0a5b397c3adc07987864b0441654dc1c/beam-1.pdf b/dev/_downloads/0a5b397c3adc07987864b0441654dc1c/beam-1.pdf index 5372d682ec668526354fd8b3a7172f240040b7f3..0562a386227679feb27c89c6ad6959c3a8b30aa4 100644 GIT binary patch delta 33 ocmZpCC(-y$qM?Pcg{g(Pg{6gc3tN#XtA&BFsp0l=Q?@Qf0L$tMjQ{`u delta 33 ocmZpCC(-y$qM?Pcg{g(Pg{6gc3tN#XtFe)>iRJckQ?@Qf0L%9ZkpKVy diff --git a/dev/_downloads/0c7c1262b6b611b1944eed12f33413fe/beam-5.pdf b/dev/_downloads/0c7c1262b6b611b1944eed12f33413fe/beam-5.pdf index 946e328ad31f6c7912ef84aa52d13cd26f43c2f0..2d448a581a2b1c3cdcb8a36dd8490204480ff1ae 100644 GIT binary patch delta 18 ZcmX?}cRX*yUn5ov17lN@%}mCwEC5a!27~|r delta 18 ZcmX?}cRX*yUn5pyBV$v;%}mCwEC5aC27Ukl diff --git a/dev/_downloads/0eb265c8614c7bd3f16f6034d076f6d3/beam-21.pdf b/dev/_downloads/0eb265c8614c7bd3f16f6034d076f6d3/beam-21.pdf index 05db381d3370580e95a198b89d859ce319eb2001..9839846db48e290a82060409afb3b17e1fbf39fb 100644 GIT binary patch delta 18 ZcmcbadNXyyc0E=L0}}(|&3p7@SpZH42Gjrm delta 18 ZcmcbadNXyyc0E>OBNGF|&3p7@SpZGj2G0Nh diff --git a/dev/_downloads/0efc8f797e345bcc903c8f4dab4a5322/plotting-4.pdf b/dev/_downloads/0efc8f797e345bcc903c8f4dab4a5322/plotting-4.pdf index ce938f5b69ebd142f55024379b8ccb6b8e5470fb..a3dcdff35a9ec9dad02b3939f4f5f0cec679e102 100644 GIT binary patch delta 18 ZcmezB`qg!VhytsHfr*jDW=VxROaMc|1}*>q delta 18 ZcmezB`qg!Vhytszk%^JnW=VxROaMcc1}Ojl diff --git a/dev/_downloads/0ffd2a0f4570e502b64ad8529258801f/plotting-17.pdf b/dev/_downloads/0ffd2a0f4570e502b64ad8529258801f/plotting-17.pdf index facd9409d12abf9dcf121c19a4ec58f837d62cf2..3dd15ba91c1f69d5f5e3275085df8ff460c757f2 100644 GIT binary patch delta 37 scmdn|OJVabg@zW!7N!>F7M2#)7Pc1lEgT|NtQH0)CT80utvIBZ0R=e=7XSbN delta 37 scmdn|OJVabg@zW!7N!>F7M2#)7Pc1lEgT|Ntj0zrCMMe@tvIBZ0R;#P5&!@I diff --git a/dev/_downloads/1362531cda049d5b7f4db4abe11d4178/plotting-6.pdf b/dev/_downloads/1362531cda049d5b7f4db4abe11d4178/plotting-6.pdf index 2efd0fb9e8f01d02f9b27bc3ac6bd8603ba57c9c..5cf401a1bb6a16a465df6ef73dc61d93a5e6df6c 100644 GIT binary patch delta 18 ZcmbR2HQ8%}oD!>rfr*jjW@V)hOaM4k1)%@{ delta 18 ZcmbR2HQ8%}oD!?Ck%^J{W@V)hOaM421)Kl? diff --git a/dev/_downloads/14bd882358332276f28c2e3ace8343d5/control_plots-5.pdf b/dev/_downloads/14bd882358332276f28c2e3ace8343d5/control_plots-5.pdf index cee7f316ebb5b3aceb0bd245c947440531c604e8..2478dd9089f10b5fa20811b9e254a41cc4b3592a 100644 GIT binary patch delta 18 acmaD__q1-qVk=e)0~15@%`2?-vH$>6eh0Gv delta 18 acmaD__q1-qVk=f-BNIcD%`2?-vH$>6Ob4w1 diff --git a/dev/_downloads/16c046e4f150f3aca5fb6bd438b952ce/matrices-24.pdf b/dev/_downloads/16c046e4f150f3aca5fb6bd438b952ce/matrices-24.pdf index 600c194a1648dfdba534d7fc221d914599e15e71..47817814323881a6bb08aeb991133e00aaf59d64 100644 GIT binary patch delta 29 kcmaEQM&Rigfrb{w7N!>FEi7`%tQH2wCdS*9m06sa0jKQ<+W-In delta 29 kcmaEQM&Rigfrb{w7N!>FEi7`%tj0#hCI;J;m06sa0jISH)c^nh diff --git a/dev/_downloads/16f8dba9abaa041f16c4636d6e41a0ac/matrices-25.pdf b/dev/_downloads/16f8dba9abaa041f16c4636d6e41a0ac/matrices-25.pdf index a43e185476c1ab3f8209e8fb6e0870b3f02034d0..4dcc2d53cdc478cb4e41cbff9386657d43f86915 100644 GIT binary patch delta 29 kcmdmZLU7{=!G;#b7N!>FEi6KbtQH2wCZ^lP6IrB~0iPHMs{jB1 delta 29 kcmdmZLU7{=!G;#b7N!>FEi6Kbtj0#hCdS*v6IrB~0iNdwrT_o{ diff --git a/dev/_downloads/1f24a27fa4a24f0b331e9442f61363d7/plotting-16.pdf b/dev/_downloads/1f24a27fa4a24f0b331e9442f61363d7/plotting-16.pdf index 38536e65c80caa2531ba21a71e4b48c3629ef589..9a4b71fad0951224b9d3a87ce39267d58abae0de 100644 GIT binary patch delta 37 tcmeBJuF$bup`nGbg{g(Pg{6hHg{_5s3&%tORtp0YW6SN+1UNo10RZb43z`4` delta 37 tcmeBJuF$bup`nGbg{g(Pg{6hHg{_5s3&%tOR%0U*WAp9P1UNo10RZae3zYx> diff --git a/dev/_downloads/2019cb6b524d1d6351bac9c894de42dd/plotting-26.hires.png b/dev/_downloads/2019cb6b524d1d6351bac9c894de42dd/plotting-26.hires.png index 2eaf5140c92f4477106f654695292227ccae45ef..619491bd69232fab1425f7be46bc59324719d14e 100644 GIT binary patch literal 30768 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�U;W79~$L@EBN7&JaWCO(p*duI004nC) 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 literal 30783 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 |o)X>16vjiK?>?|fP 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 T9tu0icW2jL2j+C diff --git a/dev/_downloads/2082eb4d6b0c42668444836c10a5a149/beam_problems-14.pdf b/dev/_downloads/2082eb4d6b0c42668444836c10a5a149/beam_problems-14.pdf index 30ad20f4eb06d98c88e1db7e2063dfb664a51313..e95d3c027101af61bf0ef26efaf954c6567ebbbe 100644 GIT binary patch delta 20 ccmaFf!uY&}al=wuRtp0YL&MFhZ1=JN09g?S$p8QV delta 20 ccmaFf!uY&}al=wuR%0U*1Ix{;Z1=JN09hIb%>V!Z diff --git a/dev/_downloads/2454d35ad3fc284cb67b6c619b4246c1/beam-8.pdf b/dev/_downloads/2454d35ad3fc284cb67b6c619b4246c1/beam-8.pdf index bd0498b78f873f97b4fdb71dba8e4807509f7a20..cd4680c3a97bbe8f25d3c8446226e86653316d67 100644 GIT binary patch delta 18 ZcmZ4Dzr=roxeBX=fw8ICW*e0ZW&k_s1$zJh delta 18 ZcmZ4Dzr=roxeBYXk+G@CW*e0ZW&k_A1$F=c diff --git a/dev/_downloads/2608cc95ac952e335ca0ce8cea458c1b/matrices-22.pdf b/dev/_downloads/2608cc95ac952e335ca0ce8cea458c1b/matrices-22.pdf index cd5d419927026477297ff652c21f371da96c3ff5..5db71f8cb774488aa314e662ae4fa217d37eff50 100644 GIT binary patch delta 27 jcmezJkMGMrzJ?aY7N#xCx_ekH42+GFEi7`%tQH1FrUu)Um06sa0jJjp*Z=?k delta 29 kcmaEQM&Rigfrb{w7N!>FEi7`%tj0!0CT81}m06sa0jJgo+5i9m diff --git a/dev/_downloads/26aeb23613c82467dc9ad9bdc328ab32/plotting-32_00.pdf b/dev/_downloads/26aeb23613c82467dc9ad9bdc328ab32/plotting-32_00.pdf index d54ea10277b44920aec51f7ecf9eeca68f403ed0..c33faef938aeb01b8a2f7d902e1e9deb2fbd5313 100644 GIT binary patch delta 18 ZcmX@_ao%G?o+7J-fvJJv=3>P=OaMgh29^K- delta 18 ZcmX@_ao%G?o+7KUk%_70=3>P=OaMh12A==` diff --git a/dev/_downloads/295bb235d3caa42841a5fbfa905580df/beam_problems-18.pdf b/dev/_downloads/295bb235d3caa42841a5fbfa905580df/beam_problems-18.pdf index 079fbfaf8a3bd8def2d58877ced3eb9e7f169a0e..3bf09ce5c10764fe420d8e12440c35aa4394c177 100644 GIT binary patch delta 18 ZcmZn-Y7N@(LY39Rz{Jpa^IKI3W&lGq22lV2 delta 18 ZcmZn-Y7N@(LY39n$i&ca^IKI3W&lG82220| diff --git a/dev/_downloads/2acde0fab574588f4a28670019a75bf9/plotting-26.pdf b/dev/_downloads/2acde0fab574588f4a28670019a75bf9/plotting-26.pdf index d21f7e4c4ae5da7b23e176758c134bccf6a42858..b7825901d0ef9c8baa439a75912d43a2f0479562 100644 GIT binary patch literal 129271 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

}@PslC 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

-class sympy.physics.quantum.gate.CGate(*args, **kwargs)[source]
+class sympy.physics.quantum.gate.CGate(*args, **kwargs)[source]

A general unitary gate with control qubits.

A general control gate applies a target gate to a set of targets if all of the control qubits have a particular values (set by @@ -837,13 +837,13 @@

Documentation Version
-decompose(**options)[source]
+decompose(**options)[source]

Decompose the controlled gate into CNOT and single qubits gates.

-eval_controls(qubit)[source]
+eval_controls(qubit)[source]

Return True/False to indicate if the controls are satisfied.

@@ -869,7 +869,7 @@
Documentation Version
-plot_gate(circ_plot, gate_idx)[source]
+plot_gate(circ_plot, gate_idx)[source]

Plot the controlled gate. If simplify_cgate is true, simplify C-X and C-Z gates into their more familiar forms.

@@ -884,20 +884,20 @@
Documentation Version
-class sympy.physics.quantum.gate.CGateS(*args, **kwargs)[source]
+class sympy.physics.quantum.gate.CGateS(*args, **kwargs)[source]

Version of CGate that allows gate simplifications. I.e. cnot looks like an oplus, cphase has dots, etc.

-sympy.physics.quantum.gate.CNOT[source]
+sympy.physics.quantum.gate.CNOT[source]

alias of CNotGate

-class sympy.physics.quantum.gate.CNotGate(*args, **kwargs)[source]
+class sympy.physics.quantum.gate.CNotGate(*args, **kwargs)[source]

Two qubit controlled-NOT.

This gate performs the NOT or X gate on the target qubit if the control qubits all have the value 1.

@@ -946,7 +946,7 @@
Documentation Version
-class sympy.physics.quantum.gate.Gate(*args, **kwargs)[source]
+class sympy.physics.quantum.gate.Gate(*args, **kwargs)[source]

Non-controlled unitary gate operator that acts on qubits.

This is a general abstract gate that needs to be subclassed to do anything useful.

@@ -960,7 +960,7 @@
Documentation Version
-get_target_matrix(format='sympy')[source]
+get_target_matrix(format='sympy')[source]

The matrix representation of the target part of the gate.

Parameters:
@@ -996,13 +996,13 @@
Documentation Version
-sympy.physics.quantum.gate.H[source]
+sympy.physics.quantum.gate.H[source]

alias of HadamardGate

-class sympy.physics.quantum.gate.HadamardGate(*args, **kwargs)[source]
+class sympy.physics.quantum.gate.HadamardGate(*args, **kwargs)[source]

The single qubit Hadamard gate.

Parameters:
@@ -1029,7 +1029,7 @@
Documentation Version
-class sympy.physics.quantum.gate.IdentityGate(*args, **kwargs)[source]
+class sympy.physics.quantum.gate.IdentityGate(*args, **kwargs)[source]

The single qubit identity gate.

Parameters:
@@ -1043,19 +1043,19 @@
Documentation Version
-class sympy.physics.quantum.gate.OneQubitGate(*args, **kwargs)[source]
+class sympy.physics.quantum.gate.OneQubitGate(*args, **kwargs)[source]

A single qubit unitary gate base class.

-sympy.physics.quantum.gate.Phase[source]
+sympy.physics.quantum.gate.Phase[source]

alias of PhaseGate

-class sympy.physics.quantum.gate.PhaseGate(*args, **kwargs)[source]
+class sympy.physics.quantum.gate.PhaseGate(*args, **kwargs)[source]

The single qubit phase, or S, gate.

This gate rotates the phase of the state by pi/2 if the state is |1> and does nothing if the state is |0>.

@@ -1071,19 +1071,19 @@
Documentation Version
-sympy.physics.quantum.gate.S[source]
+sympy.physics.quantum.gate.S[source]

alias of PhaseGate

-sympy.physics.quantum.gate.SWAP[source]
+sympy.physics.quantum.gate.SWAP[source]

alias of SwapGate

-class sympy.physics.quantum.gate.SwapGate(*args, **kwargs)[source]
+class sympy.physics.quantum.gate.SwapGate(*args, **kwargs)[source]

Two qubit SWAP gate.

This gate swap the values of the two qubits.

@@ -1096,7 +1096,7 @@
Documentation Version
-decompose(**options)[source]
+decompose(**options)[source]

Decompose the SWAP gate into CNOT gates.

@@ -1104,13 +1104,13 @@
Documentation Version
-sympy.physics.quantum.gate.T[source]
+sympy.physics.quantum.gate.T[source]

alias of TGate

-class sympy.physics.quantum.gate.TGate(*args, **kwargs)[source]
+class sympy.physics.quantum.gate.TGate(*args, **kwargs)[source]

The single qubit pi/8 gate.

This gate rotates the phase of the state by pi/4 if the state is |1> and does nothing if the state is |0>.

@@ -1126,13 +1126,13 @@
Documentation Version
-class sympy.physics.quantum.gate.TwoQubitGate(*args, **kwargs)[source]
+class sympy.physics.quantum.gate.TwoQubitGate(*args, **kwargs)[source]

A two qubit unitary gate base class.

-class sympy.physics.quantum.gate.UGate(*args, **kwargs)[source]
+class sympy.physics.quantum.gate.UGate(*args, **kwargs)[source]

General gate specified by a set of targets and a target matrix.

Parameters:
@@ -1146,7 +1146,7 @@
Documentation Version
-get_target_matrix(format='sympy')[source]
+get_target_matrix(format='sympy')[source]

The matrix rep. of the target part of the gate.

Parameters:
@@ -1168,13 +1168,13 @@
Documentation Version
-sympy.physics.quantum.gate.X[source]
+sympy.physics.quantum.gate.X[source]

alias of XGate

-class sympy.physics.quantum.gate.XGate(*args, **kwargs)[source]
+class sympy.physics.quantum.gate.XGate(*args, **kwargs)[source]

The single qubit X, or NOT, gate.

Parameters:
@@ -1188,13 +1188,13 @@
Documentation Version
-sympy.physics.quantum.gate.Y[source]
+sympy.physics.quantum.gate.Y[source]

alias of YGate

-class sympy.physics.quantum.gate.YGate(*args, **kwargs)[source]
+class sympy.physics.quantum.gate.YGate(*args, **kwargs)[source]

The single qubit Y gate.

Parameters:
@@ -1208,13 +1208,13 @@
Documentation Version
-sympy.physics.quantum.gate.Z[source]
+sympy.physics.quantum.gate.Z[source]

alias of ZGate

-class sympy.physics.quantum.gate.ZGate(*args, **kwargs)[source]
+class sympy.physics.quantum.gate.ZGate(*args, **kwargs)[source]

The single qubit Z gate.

Parameters:
@@ -1228,7 +1228,7 @@
Documentation Version
-sympy.physics.quantum.gate.gate_simp(circuit)[source]
+sympy.physics.quantum.gate.gate_simp(circuit)[source]

Simplifies gates symbolically

It first sorts gates using gate_sort. It then applies basic simplification rules to the circuit, e.g., XGate**2 = Identity

@@ -1236,7 +1236,7 @@
Documentation Version
-sympy.physics.quantum.gate.gate_sort(circuit)[source]
+sympy.physics.quantum.gate.gate_sort(circuit)[source]

Sorts the gates while keeping track of commutation relations

This function uses a bubble sort to rearrange the order of gate application. Keeps track of Quantum computations special commutation @@ -1247,7 +1247,7 @@

Documentation Version
-sympy.physics.quantum.gate.normalized(normalize)[source]
+sympy.physics.quantum.gate.normalized(normalize)[source]

Set flag controlling normalization of Hadamard gates by \(1/\sqrt{2}\).

This is a global setting that can be used to simplify the look of various expressions, by leaving off the leading \(1/\sqrt{2}\) of the Hadamard gate.

@@ -1280,7 +1280,7 @@
Documentation Version
<class 'sympy.physics.quantum.gate.SwapGate'>),
-)[source] +)[source]

Return a random circuit of ngates and nqubits.

This uses an equally weighted sample of (X, Y, Z, S, T, H, CNOT, SWAP) gates.

diff --git a/dev/modules/physics/quantum/grover.html b/dev/modules/physics/quantum/grover.html index 07e1a9e494c..8efff891184 100644 --- a/dev/modules/physics/quantum/grover.html +++ b/dev/modules/physics/quantum/grover.html @@ -810,7 +810,7 @@
Documentation Version
-class sympy.physics.quantum.grover.OracleGate(*args, **kwargs)[source]
+class sympy.physics.quantum.grover.OracleGate(*args, **kwargs)[source]

A black box gate.

The gate marks the desired qubits of an unknown function by flipping the sign of the qubits. The unknown function returns true when it @@ -856,7 +856,7 @@

Documentation Version
-class sympy.physics.quantum.grover.WGate(*args, **kwargs)[source]
+class sympy.physics.quantum.grover.WGate(*args, **kwargs)[source]

General n qubit W Gate in Grover’s algorithm.

The gate performs the operation 2|phi><phi| - 1 on some qubits. |phi> = (tensor product of n Hadamards)*(|0> with n qubits)

@@ -872,7 +872,7 @@
Documentation Version
-sympy.physics.quantum.grover.apply_grover(oracle, nqubits, iterations=None)[source]
+sympy.physics.quantum.grover.apply_grover(oracle, nqubits, iterations=None)[source]

Applies grover’s algorithm.

Parameters:
@@ -903,7 +903,7 @@
Documentation Version
-sympy.physics.quantum.grover.grover_iteration(qstate, oracle)[source]
+sympy.physics.quantum.grover.grover_iteration(qstate, oracle)[source]

Applies one application of the Oracle and W Gate, WV.

Parameters:
@@ -939,7 +939,7 @@
Documentation Version
-sympy.physics.quantum.grover.superposition_basis(nqubits)[source]
+sympy.physics.quantum.grover.superposition_basis(nqubits)[source]

Creates an equal superposition of the computational basis.

Parameters:
diff --git a/dev/modules/physics/quantum/hilbert.html b/dev/modules/physics/quantum/hilbert.html index 9409351887d..8e559a93d9f 100644 --- a/dev/modules/physics/quantum/hilbert.html +++ b/dev/modules/physics/quantum/hilbert.html @@ -806,7 +806,7 @@
Documentation Version
* Matt Curry

-class sympy.physics.quantum.hilbert.ComplexSpace(dimension)[source]
+class sympy.physics.quantum.hilbert.ComplexSpace(dimension)[source]

Finite dimensional Hilbert space of complex vectors.

The elements of this Hilbert space are n-dimensional complex valued vectors with the usual inner product that takes the complex conjugate @@ -837,7 +837,7 @@

Documentation Version
-class sympy.physics.quantum.hilbert.DirectSumHilbertSpace(*args)[source]
+class sympy.physics.quantum.hilbert.DirectSumHilbertSpace(*args)[source]

A direct sum of Hilbert spaces [R766].

This class uses the + operator to represent direct sums between different Hilbert spaces.

@@ -869,7 +869,7 @@
Documentation Version
-classmethod eval(args)[source]
+classmethod eval(args)[source]

Evaluates the direct product.

@@ -883,7 +883,7 @@
Documentation Version
-class sympy.physics.quantum.hilbert.FockSpace[source]
+class sympy.physics.quantum.hilbert.FockSpace[source]

The Hilbert space for second quantization.

Technically, this Hilbert space is a infinite direct sum of direct products of single particle Hilbert spaces [R767]. This is a mess, so we have @@ -909,7 +909,7 @@

Documentation Version
-class sympy.physics.quantum.hilbert.HilbertSpace[source]
+class sympy.physics.quantum.hilbert.HilbertSpace[source]

An abstract Hilbert space for quantum mechanics.

In short, a Hilbert space is an abstract vector space that is complete with inner products defined [R768].

@@ -938,7 +938,7 @@
Documentation Version
-class sympy.physics.quantum.hilbert.L2(interval)[source]
+class sympy.physics.quantum.hilbert.L2(interval)[source]

The Hilbert space of square integrable functions on an interval.

An L2 object takes in a single SymPy Interval argument which represents the interval its functions (vectors) are defined on.

@@ -958,7 +958,7 @@
Documentation Version
-class sympy.physics.quantum.hilbert.TensorPowerHilbertSpace(*args)[source]
+class sympy.physics.quantum.hilbert.TensorPowerHilbertSpace(*args)[source]

An exponentiated Hilbert space [R769].

Tensor powers (repeated tensor products) are represented by the operator ** Identical Hilbert spaces that are multiplied together @@ -1000,7 +1000,7 @@

Documentation Version
-class sympy.physics.quantum.hilbert.TensorProductHilbertSpace(*args)[source]
+class sympy.physics.quantum.hilbert.TensorProductHilbertSpace(*args)[source]

A tensor product of Hilbert spaces [R770].

The tensor product between Hilbert spaces is represented by the operator * Products of the same Hilbert space will be combined into @@ -1045,7 +1045,7 @@

Documentation Version
-classmethod eval(args)[source]
+classmethod eval(args)[source]

Evaluates the direct product.

diff --git a/dev/modules/physics/quantum/innerproduct.html b/dev/modules/physics/quantum/innerproduct.html index d05d56ecf28..f62a9b151c3 100644 --- a/dev/modules/physics/quantum/innerproduct.html +++ b/dev/modules/physics/quantum/innerproduct.html @@ -803,7 +803,7 @@
Documentation Version

Symbolic inner product.

-class sympy.physics.quantum.innerproduct.InnerProduct(bra, ket)[source]
+class sympy.physics.quantum.innerproduct.InnerProduct(bra, ket)[source]

An unevaluated inner product between a Bra and a Ket [1].

Parameters:
diff --git a/dev/modules/physics/quantum/operator.html b/dev/modules/physics/quantum/operator.html index 764cf4df53e..1d0c027261e 100644 --- a/dev/modules/physics/quantum/operator.html +++ b/dev/modules/physics/quantum/operator.html @@ -811,7 +811,7 @@
Documentation Version
-class sympy.physics.quantum.operator.DifferentialOperator(*args, **kwargs)[source]
+class sympy.physics.quantum.operator.DifferentialOperator(*args, **kwargs)[source]

An operator for representing the differential operator, i.e. d/dx

It is initialized by passing two arguments. The first is an arbitrary expression that involves a function, such as Derivative(f(x), x). The @@ -925,7 +925,7 @@

Documentation Version
-class sympy.physics.quantum.operator.HermitianOperator(*args, **kwargs)[source]
+class sympy.physics.quantum.operator.HermitianOperator(*args, **kwargs)[source]

A Hermitian operator that satisfies H == Dagger(H).

Parameters:
@@ -947,7 +947,7 @@
Documentation Version
-class sympy.physics.quantum.operator.IdentityOperator(*args, **kwargs)[source]
+class sympy.physics.quantum.operator.IdentityOperator(*args, **kwargs)[source]

An identity operator I that satisfies op * I == I * op == op for any operator op.

@@ -969,7 +969,7 @@
Documentation Version
-class sympy.physics.quantum.operator.Operator(*args, **kwargs)[source]
+class sympy.physics.quantum.operator.Operator(*args, **kwargs)[source]

Base class for non-commuting quantum operators.

An operator maps between quantum states [R772]. In quantum mechanics, observables (including, but not limited to, measured physical values) are @@ -1044,7 +1044,7 @@

Documentation Version
-class sympy.physics.quantum.operator.OuterProduct(*args, **old_assumptions)[source]
+class sympy.physics.quantum.operator.OuterProduct(*args, **old_assumptions)[source]

An unevaluated outer product between a ket and bra.

This constructs an outer product between any subclass of KetBase and BraBase as |a><b|. An OuterProduct inherits from Operator as they act as @@ -1124,7 +1124,7 @@

Documentation Version
-class sympy.physics.quantum.operator.UnitaryOperator(*args, **kwargs)[source]
+class sympy.physics.quantum.operator.UnitaryOperator(*args, **kwargs)[source]

A unitary operator that satisfies U*Dagger(U) == 1.

Parameters:
diff --git a/dev/modules/physics/quantum/operatorset.html b/dev/modules/physics/quantum/operatorset.html index 122f16a3dd0..e9a88dd95f9 100644 --- a/dev/modules/physics/quantum/operatorset.html +++ b/dev/modules/physics/quantum/operatorset.html @@ -813,7 +813,7 @@
Documentation Version
- Update the dictionary with a complete list of state-operator pairs

-sympy.physics.quantum.operatorset.operators_to_state(operators, **options)[source]
+sympy.physics.quantum.operatorset.operators_to_state(operators, **options)[source]

Returns the eigenstate of the given operator or set of operators

A global function for mapping operator classes to their associated states. It takes either an Operator or a set of operators and @@ -864,7 +864,7 @@

Documentation Version
-sympy.physics.quantum.operatorset.state_to_operators(state, **options)[source]
+sympy.physics.quantum.operatorset.state_to_operators(state, **options)[source]

Returns the operator or set of operators corresponding to the given eigenstate

A global function for mapping state classes to their associated diff --git a/dev/modules/physics/quantum/piab.html b/dev/modules/physics/quantum/piab.html index 6b993b328ff..f91ba54d10c 100644 --- a/dev/modules/physics/quantum/piab.html +++ b/dev/modules/physics/quantum/piab.html @@ -803,19 +803,19 @@

Documentation Version

1D quantum particle in a box.

-class sympy.physics.quantum.piab.PIABBra(*args, **kwargs)[source]
+class sympy.physics.quantum.piab.PIABBra(*args, **kwargs)[source]

Particle in a box eigenbra.

-class sympy.physics.quantum.piab.PIABHamiltonian(*args, **kwargs)[source]
+class sympy.physics.quantum.piab.PIABHamiltonian(*args, **kwargs)[source]

Particle in a box Hamiltonian operator.

-class sympy.physics.quantum.piab.PIABKet(*args, **kwargs)[source]
+class sympy.physics.quantum.piab.PIABKet(*args, **kwargs)[source]

Particle in a box eigenket.

diff --git a/dev/modules/physics/quantum/qapply.html b/dev/modules/physics/quantum/qapply.html index 56c24f9852b..339e7899539 100644 --- a/dev/modules/physics/quantum/qapply.html +++ b/dev/modules/physics/quantum/qapply.html @@ -805,7 +805,7 @@
Documentation Version
* Sometimes the final result needs to be expanded, we should do this by hand.

-sympy.physics.quantum.qapply.qapply(e, **options)[source]
+sympy.physics.quantum.qapply.qapply(e, **options)[source]

Apply operators to states in a quantum expression.

Parameters:
diff --git a/dev/modules/physics/quantum/qft.html b/dev/modules/physics/quantum/qft.html index 8105ea62a8c..3e7cb169136 100644 --- a/dev/modules/physics/quantum/qft.html +++ b/dev/modules/physics/quantum/qft.html @@ -813,11 +813,11 @@
Documentation Version
-class sympy.physics.quantum.qft.IQFT(*args, **kwargs)[source]
+class sympy.physics.quantum.qft.IQFT(*args, **kwargs)[source]

The inverse quantum Fourier transform.

-decompose()[source]
+decompose()[source]

Decomposes IQFT into elementary gates.

@@ -825,11 +825,11 @@
Documentation Version
-class sympy.physics.quantum.qft.QFT(*args, **kwargs)[source]
+class sympy.physics.quantum.qft.QFT(*args, **kwargs)[source]

The forward quantum Fourier transform.

-decompose()[source]
+decompose()[source]

Decomposes QFT into elementary gates.

@@ -837,13 +837,13 @@
Documentation Version
-sympy.physics.quantum.qft.Rk[source]
+sympy.physics.quantum.qft.Rk[source]

alias of RkGate

-class sympy.physics.quantum.qft.RkGate(*args)[source]
+class sympy.physics.quantum.qft.RkGate(*args)[source]

This is the R_k gate of the QTF.

diff --git a/dev/modules/physics/quantum/qubit.html b/dev/modules/physics/quantum/qubit.html index 01c5e962729..844197e9a97 100644 --- a/dev/modules/physics/quantum/qubit.html +++ b/dev/modules/physics/quantum/qubit.html @@ -807,7 +807,7 @@
Documentation Version
* Update tests.

-class sympy.physics.quantum.qubit.IntQubit(*args, **kwargs)[source]
+class sympy.physics.quantum.qubit.IntQubit(*args, **kwargs)[source]

A qubit ket that store integers as binary numbers in qubit values.

The differences between this class and Qubit are:

    @@ -882,13 +882,13 @@
    Documentation Version
    -class sympy.physics.quantum.qubit.IntQubitBra(*args, **kwargs)[source]
    +class sympy.physics.quantum.qubit.IntQubitBra(*args, **kwargs)[source]

    A qubit bra that store integers as binary numbers in qubit values.

    -class sympy.physics.quantum.qubit.Qubit(*args, **kwargs)[source]
    +class sympy.physics.quantum.qubit.Qubit(*args, **kwargs)[source]

    A multi-qubit ket in the computational (z) basis.

    We use the normal convention that the least significant qubit is on the right, so |00001> has a 1 in the least significant qubit.

    @@ -945,7 +945,7 @@
    Documentation Version
    -class sympy.physics.quantum.qubit.QubitBra(*args, **kwargs)[source]
    +class sympy.physics.quantum.qubit.QubitBra(*args, **kwargs)[source]

    A multi-qubit bra in the computational (z) basis.

    We use the normal convention that the least significant qubit is on the right, so |00001> has a 1 in the least significant qubit.

    @@ -968,7 +968,7 @@
    Documentation Version
    -sympy.physics.quantum.qubit.matrix_to_density(mat)[source]
    +sympy.physics.quantum.qubit.matrix_to_density(mat)[source]

    Works by finding the eigenvectors and eigenvalues of the matrix. We know we can decompose rho by doing: sum(EigenVal*|Eigenvect><Eigenvect|)

    @@ -976,7 +976,7 @@
    Documentation Version
    -sympy.physics.quantum.qubit.matrix_to_qubit(matrix)[source]
    +sympy.physics.quantum.qubit.matrix_to_qubit(matrix)[source]

    Convert from the matrix repr. to a sum of Qubit objects.

    Parameters:
    @@ -1000,7 +1000,7 @@
    Documentation Version
    -sympy.physics.quantum.qubit.measure_all(qubit, format='sympy', normalize=True)[source]
    +sympy.physics.quantum.qubit.measure_all(qubit, format='sympy', normalize=True)[source]

    Perform an ensemble measurement of all qubits.

    Parameters:
    @@ -1041,7 +1041,7 @@
    Documentation Version
    -sympy.physics.quantum.qubit.measure_all_oneshot(qubit, format='sympy')[source]
    +sympy.physics.quantum.qubit.measure_all_oneshot(qubit, format='sympy')[source]

    Perform a oneshot ensemble measurement on all qubits.

    A oneshot measurement is equivalent to performing a measurement on a quantum system. This type of measurement does not return the probabilities @@ -1082,7 +1082,7 @@

    Documentation Version
    normalize=True,
    -)[source] +)[source]

    Perform a partial ensemble measure on the specified qubits.

    Parameters:
    @@ -1135,7 +1135,7 @@
    Documentation Version
    format='sympy',
    -)[source] +)[source]

    Perform a partial oneshot measurement on the specified qubits.

    A oneshot measurement is equivalent to performing a measurement on a quantum system. This type of measurement does not return the probabilities @@ -1171,7 +1171,7 @@

    Documentation Version
    -sympy.physics.quantum.qubit.qubit_to_matrix(qubit, format='sympy')[source]
    +sympy.physics.quantum.qubit.qubit_to_matrix(qubit, format='sympy')[source]

    Converts an Add/Mul of Qubit objects into it’s matrix representation

    This function is the inverse of matrix_to_qubit and is a shorthand for represent(qubit).

    diff --git a/dev/modules/physics/quantum/represent.html b/dev/modules/physics/quantum/represent.html index 1318aa69d1e..8e9231eb144 100644 --- a/dev/modules/physics/quantum/represent.html +++ b/dev/modules/physics/quantum/represent.html @@ -808,7 +808,7 @@
    Documentation Version
-sympy.physics.quantum.represent.enumerate_states(*args, **options)[source]
+sympy.physics.quantum.represent.enumerate_states(*args, **options)[source]

Returns instances of the given state with dummy indices appended

Operates in two different modes:

    @@ -852,7 +852,7 @@
    Documentation Version
    **options,
-)[source] +)[source]

Returns a basis state instance corresponding to the basis specified in options=s. If no basis is specified, the function tries to form a default basis state of the given expression.

@@ -899,7 +899,7 @@
Documentation Version
-sympy.physics.quantum.represent.integrate_result(orig_expr, result, **options)[source]
+sympy.physics.quantum.represent.integrate_result(orig_expr, result, **options)[source]

Returns the result of integrating over any unities (|x><x|) in the given expression. Intended for integrating over the result of representations in continuous bases.

@@ -941,7 +941,7 @@
Documentation Version
-sympy.physics.quantum.represent.rep_expectation(expr, **options)[source]
+sympy.physics.quantum.represent.rep_expectation(expr, **options)[source]

Returns an <x'|A|x> type representation for the given operator.

Parameters:
@@ -966,7 +966,7 @@
Documentation Version
-sympy.physics.quantum.represent.rep_innerproduct(expr, **options)[source]
+sympy.physics.quantum.represent.rep_innerproduct(expr, **options)[source]

Returns an innerproduct like representation (e.g. <x'|x>) for the given state.

Attempts to calculate inner product with a bra from the specified @@ -994,7 +994,7 @@

Documentation Version
-sympy.physics.quantum.represent.represent(expr, **options)[source]
+sympy.physics.quantum.represent.represent(expr, **options)[source]

Represent the quantum expression in the given basis.

In quantum mechanics abstract states and operators can be represented in various basis sets. Under this operation the follow transforms happen:

diff --git a/dev/modules/physics/quantum/shor.html b/dev/modules/physics/quantum/shor.html index f9d94a60d16..d4a51b0bc09 100644 --- a/dev/modules/physics/quantum/shor.html +++ b/dev/modules/physics/quantum/shor.html @@ -809,7 +809,7 @@
Documentation Version
-class sympy.physics.quantum.shor.CMod(*args, **kwargs)[source]
+class sympy.physics.quantum.shor.CMod(*args, **kwargs)[source]

A controlled mod gate.

This is black box controlled Mod function for use by shor’s algorithm. TODO: implement a decompose property that returns how to do this in terms @@ -836,7 +836,7 @@

Documentation Version
-sympy.physics.quantum.shor.period_find(a, N)[source]
+sympy.physics.quantum.shor.period_find(a, N)[source]

Finds the period of a in modulo N arithmetic

This is quantum part of Shor’s algorithm. It takes two registers, puts first in superposition of states with Hadamards so: |k>|0> @@ -846,7 +846,7 @@

Documentation Version
-sympy.physics.quantum.shor.shor(N)[source]
+sympy.physics.quantum.shor.shor(N)[source]

This function implements Shor’s factoring algorithm on the Integer N

The algorithm starts by picking a random number (a) and seeing if it is coprime with N. If it is not, then the gcd of the two numbers is a factor diff --git a/dev/modules/physics/quantum/spin.html b/dev/modules/physics/quantum/spin.html index 219ed639e26..f2d991130a4 100644 --- a/dev/modules/physics/quantum/spin.html +++ b/dev/modules/physics/quantum/spin.html @@ -803,13 +803,13 @@

Documentation Version

Quantum mechanical angular momemtum.

-class sympy.physics.quantum.spin.J2Op(*args, **kwargs)[source]
+class sympy.physics.quantum.spin.J2Op(*args, **kwargs)[source]

The J^2 operator.

-class sympy.physics.quantum.spin.JxBra(j, m)[source]
+class sympy.physics.quantum.spin.JxBra(j, m)[source]

Eigenbra of Jx.

See JzKet for the usage of spin eigenstates.

@@ -823,7 +823,7 @@
Documentation Version
-class sympy.physics.quantum.spin.JxBraCoupled(j, m, jn, *jcoupling)[source]
+class sympy.physics.quantum.spin.JxBraCoupled(j, m, jn, *jcoupling)[source]

Coupled eigenbra of Jx.

See JzKetCoupled for the usage of coupled spin eigenstates.

@@ -837,7 +837,7 @@
Documentation Version
-class sympy.physics.quantum.spin.JxKet(j, m)[source]
+class sympy.physics.quantum.spin.JxKet(j, m)[source]

Eigenket of Jx.

See JzKet for the usage of spin eigenstates.

@@ -851,7 +851,7 @@
Documentation Version
-class sympy.physics.quantum.spin.JxKetCoupled(j, m, jn, *jcoupling)[source]
+class sympy.physics.quantum.spin.JxKetCoupled(j, m, jn, *jcoupling)[source]

Coupled eigenket of Jx.

See JzKetCoupled for the usage of coupled spin eigenstates.

@@ -865,7 +865,7 @@
Documentation Version
-class sympy.physics.quantum.spin.JyBra(j, m)[source]
+class sympy.physics.quantum.spin.JyBra(j, m)[source]

Eigenbra of Jy.

See JzKet for the usage of spin eigenstates.

@@ -879,7 +879,7 @@
Documentation Version
-class sympy.physics.quantum.spin.JyBraCoupled(j, m, jn, *jcoupling)[source]
+class sympy.physics.quantum.spin.JyBraCoupled(j, m, jn, *jcoupling)[source]

Coupled eigenbra of Jy.

See JzKetCoupled for the usage of coupled spin eigenstates.

@@ -893,7 +893,7 @@
Documentation Version
-class sympy.physics.quantum.spin.JyKet(j, m)[source]
+class sympy.physics.quantum.spin.JyKet(j, m)[source]

Eigenket of Jy.

See JzKet for the usage of spin eigenstates.

@@ -907,7 +907,7 @@
Documentation Version
-class sympy.physics.quantum.spin.JyKetCoupled(j, m, jn, *jcoupling)[source]
+class sympy.physics.quantum.spin.JyKetCoupled(j, m, jn, *jcoupling)[source]

Coupled eigenket of Jy.

See JzKetCoupled for the usage of coupled spin eigenstates.

@@ -921,7 +921,7 @@
Documentation Version
-class sympy.physics.quantum.spin.JzBra(j, m)[source]
+class sympy.physics.quantum.spin.JzBra(j, m)[source]

Eigenbra of Jz.

See the JzKet for the usage of spin eigenstates.

@@ -935,7 +935,7 @@
Documentation Version
-class sympy.physics.quantum.spin.JzBraCoupled(j, m, jn, *jcoupling)[source]
+class sympy.physics.quantum.spin.JzBraCoupled(j, m, jn, *jcoupling)[source]

Coupled eigenbra of Jz.

See the JzKetCoupled for the usage of coupled spin eigenstates.

@@ -949,7 +949,7 @@
Documentation Version
-class sympy.physics.quantum.spin.JzKet(j, m)[source]
+class sympy.physics.quantum.spin.JzKet(j, m)[source]

Eigenket of Jz.

Spin state which is an eigenstate of the Jz operator. Uncoupled states, that is states representing the interaction of multiple separate spin @@ -1065,7 +1065,7 @@

Documentation Version
-class sympy.physics.quantum.spin.JzKetCoupled(j, m, jn, *jcoupling)[source]
+class sympy.physics.quantum.spin.JzKetCoupled(j, m, jn, *jcoupling)[source]

Coupled eigenket of Jz

Spin state that is an eigenket of Jz which represents the coupling of separate spin spaces.

@@ -1183,13 +1183,13 @@
Documentation Version
-class sympy.physics.quantum.spin.JzOp(*args, **kwargs)[source]
+class sympy.physics.quantum.spin.JzOp(*args, **kwargs)[source]

The Jz operator.

-class sympy.physics.quantum.spin.Rotation(*args, **kwargs)[source]
+class sympy.physics.quantum.spin.Rotation(*args, **kwargs)[source]

Wigner D operator in terms of Euler angles.

Defines the rotation operator in terms of the Euler angles defined by the z-y-z convention for a passive transformation. That is the coordinate @@ -1251,7 +1251,7 @@

Documentation Version
-classmethod D(j, m, mp, alpha, beta, gamma)[source]
+classmethod D(j, m, mp, alpha, beta, gamma)[source]

Wigner D-function.

Returns an instance of the WignerD class corresponding to the Wigner-D function specified by the parameters.

@@ -1304,7 +1304,7 @@
Documentation Version
-classmethod d(j, m, mp, beta)[source]
+classmethod d(j, m, mp, beta)[source]

Wigner small-d function.

Returns an instance of the WignerD class corresponding to the Wigner-D function specified by the parameters with the alpha and gamma angles @@ -1352,7 +1352,7 @@

Documentation Version
-class sympy.physics.quantum.spin.WignerD(*args, **hints)[source]
+class sympy.physics.quantum.spin.WignerD(*args, **hints)[source]

Wigner-D function

The Wigner D-function gives the matrix elements of the rotation operator in the jm-representation. For the Euler angles \(\alpha\), @@ -1445,7 +1445,7 @@

Documentation Version
-sympy.physics.quantum.spin.couple(expr, jcoupling_list=None)[source]
+sympy.physics.quantum.spin.couple(expr, jcoupling_list=None)[source]

Couple a tensor product of spin states

This function can be used to couple an uncoupled tensor product of spin states. All of the eigenstates to be coupled must be of the same class. It @@ -1504,7 +1504,7 @@

Documentation Version
-sympy.physics.quantum.spin.uncouple(expr, jn=None, jcoupling_list=None)[source]
+sympy.physics.quantum.spin.uncouple(expr, jn=None, jcoupling_list=None)[source]

Uncouple a coupled spin state

Gives the uncoupled representation of a coupled spin state. Arguments must be either a spin state that is a subclass of CoupledSpinState or a spin diff --git a/dev/modules/physics/quantum/state.html b/dev/modules/physics/quantum/state.html index 9c87ce739e5..0f6376e35ea 100644 --- a/dev/modules/physics/quantum/state.html +++ b/dev/modules/physics/quantum/state.html @@ -803,7 +803,7 @@

Documentation Version

Dirac notation for states.

-class sympy.physics.quantum.state.Bra(*args, **kwargs)[source]
+class sympy.physics.quantum.state.Bra(*args, **kwargs)[source]

A general time-independent Bra in quantum mechanics.

Inherits from State and BraBase. A Bra is the dual of a Ket [R777]. This class and its subclasses will be the main classes that users will use for @@ -863,7 +863,7 @@

Documentation Version
-class sympy.physics.quantum.state.BraBase(*args, **kwargs)[source]
+class sympy.physics.quantum.state.BraBase(*args, **kwargs)[source]

Base class for Bras.

This class defines the dual property and the brackets for printing. This is an abstract base class and you should not instantiate it directly, @@ -872,7 +872,7 @@

Documentation Version
-class sympy.physics.quantum.state.Ket(*args, **kwargs)[source]
+class sympy.physics.quantum.state.Ket(*args, **kwargs)[source]

A general time-independent Ket in quantum mechanics.

Inherits from State and KetBase. This class should be used as the base class for all physical, time-independent Kets in a system. This class @@ -936,7 +936,7 @@

Documentation Version
-class sympy.physics.quantum.state.KetBase(*args, **kwargs)[source]
+class sympy.physics.quantum.state.KetBase(*args, **kwargs)[source]

Base class for Kets.

This class defines the dual property and the brackets for printing. This is an abstract base class and you should not instantiate it directly, instead @@ -945,13 +945,13 @@

Documentation Version
-class sympy.physics.quantum.state.OrthogonalBra(*args, **kwargs)[source]
+class sympy.physics.quantum.state.OrthogonalBra(*args, **kwargs)[source]

Orthogonal Bra in quantum mechanics.

-class sympy.physics.quantum.state.OrthogonalKet(*args, **kwargs)[source]
+class sympy.physics.quantum.state.OrthogonalKet(*args, **kwargs)[source]

Orthogonal Ket in quantum mechanics.

The inner product of two states with different labels will give zero, states with the same label will give one.

@@ -969,19 +969,19 @@
Documentation Version
-class sympy.physics.quantum.state.OrthogonalState(*args, **kwargs)[source]
+class sympy.physics.quantum.state.OrthogonalState(*args, **kwargs)[source]

General abstract quantum state used as a base class for Ket and Bra.

-class sympy.physics.quantum.state.State(*args, **kwargs)[source]
+class sympy.physics.quantum.state.State(*args, **kwargs)[source]

General abstract quantum state used as a base class for Ket and Bra.

-class sympy.physics.quantum.state.StateBase(*args, **kwargs)[source]
+class sympy.physics.quantum.state.StateBase(*args, **kwargs)[source]

Abstract base class for general abstract states in quantum mechanics.

All other state classes defined will need to inherit from this class. It carries the basic structure for all other states such as dual, _eval_adjoint @@ -996,7 +996,7 @@

Documentation Version
-classmethod dual_class()[source]
+classmethod dual_class()[source]

Return the class used to construct the dual.

@@ -1010,7 +1010,7 @@
Documentation Version
-class sympy.physics.quantum.state.TimeDepBra(*args, **kwargs)[source]
+class sympy.physics.quantum.state.TimeDepBra(*args, **kwargs)[source]

General time-dependent Bra in quantum mechanics.

This inherits from TimeDepState and BraBase and is the main class that should be used for Bras that vary with time. Its dual is a TimeDepBra.

@@ -1043,7 +1043,7 @@
Documentation Version
-class sympy.physics.quantum.state.TimeDepKet(*args, **kwargs)[source]
+class sympy.physics.quantum.state.TimeDepKet(*args, **kwargs)[source]

General time-dependent Ket in quantum mechanics.

This inherits from TimeDepState and KetBase and is the main class that should be used for Kets that vary with time. Its dual is a @@ -1083,7 +1083,7 @@

Documentation Version
-class sympy.physics.quantum.state.TimeDepState(*args, **kwargs)[source]
+class sympy.physics.quantum.state.TimeDepState(*args, **kwargs)[source]

Base class for a general time-dependent quantum state.

This class is used as a base class for any time-dependent state. The main difference between this class and the time-independent state is that this @@ -1115,7 +1115,7 @@

Documentation Version
-class sympy.physics.quantum.state.Wavefunction(*args)[source]
+class sympy.physics.quantum.state.Wavefunction(*args)[source]

Class for representations in continuous bases

This class takes an expression and coordinates in its constructor. It can be used to easily calculate normalizations and probabilities.

@@ -1285,7 +1285,7 @@
Documentation Version
-normalize()[source]
+normalize()[source]

Return a normalized version of the Wavefunction

Examples

>>> from sympy import symbols, pi
@@ -1304,7 +1304,7 @@ 
Documentation Version

 
 

 

-prob()[source]

+prob()[source]
 
Return the absolute magnitude of the w.f., \(|\psi(x)|^2\)

 
Examples

 
>>> from sympy import symbols, pi
diff --git a/dev/modules/physics/quantum/tensorproduct.html b/dev/modules/physics/quantum/tensorproduct.html
index f5d5221af97..2cd2ad5a181 100644
--- a/dev/modules/physics/quantum/tensorproduct.html
+++ b/dev/modules/physics/quantum/tensorproduct.html
@@ -803,7 +803,7 @@ 
Documentation Version

 
Abstract tensor product.

 

 

-class sympy.physics.quantum.tensorproduct.TensorProduct(*args)[source]

+class sympy.physics.quantum.tensorproduct.TensorProduct(*args)[source]
 
The tensor product of two or more arguments.

 
For matrices, this uses matrix_tensor_product to compute the Kronecker
 or tensor product matrix. For other objects a symbolic TensorProduct
@@ -872,7 +872,7 @@ 
Documentation Version

 
 

 

-sympy.physics.quantum.tensorproduct.tensor_product_simp(e, **hints)[source]

+sympy.physics.quantum.tensorproduct.tensor_product_simp(e, **hints)[source]
 
Try to simplify and combine TensorProducts.

 
In general this will try to pull expressions inside of TensorProducts.
 It currently only works for relatively simple cases where the products have
diff --git a/dev/modules/physics/secondquant.html b/dev/modules/physics/secondquant.html
index ea8e92e86a3..377ef26a0ee 100644
--- a/dev/modules/physics/secondquant.html
+++ b/dev/modules/physics/secondquant.html
@@ -805,7 +805,7 @@ 
Documentation Version

 of Many-Particle Systems.”

 

 

-class sympy.physics.secondquant.AnnihilateBoson(k)[source]

+class sympy.physics.secondquant.AnnihilateBoson(k)[source]
 
Bosonic annihilation operator.

 
Examples

 
>>> from sympy.physics.secondquant import B
@@ -816,7 +816,7 @@ 
Documentation Version

 

 

 

-apply_operator(state)[source]

+apply_operator(state)[source]
 
Apply state to self if self is not symbolic and state is a FockStateKet, else
 multiply self by state.

 
Examples

@@ -834,11 +834,11 @@ 
Documentation Version

 
 

 

-class sympy.physics.secondquant.AnnihilateFermion(k)[source]

+class sympy.physics.secondquant.AnnihilateFermion(k)[source]
 
Fermionic annihilation operator.

 

 

-apply_operator(state)[source]

+apply_operator(state)[source]
 
Apply state to self if self is not symbolic and state is a FockStateKet, else
 multiply self by state.

 
Examples

@@ -946,7 +946,7 @@ 
Documentation Version

 
 

 

-class sympy.physics.secondquant.AntiSymmetricTensor(symbol, upper, lower)[source]

+class sympy.physics.secondquant.AntiSymmetricTensor(symbol, upper, lower)[source]
 
Stores upper and lower indices in separate Tuple’s.

 
Each group of indices is assumed to be antisymmetric.

 
Examples

@@ -1016,37 +1016,37 @@ 
Documentation Version

 
 

 

-sympy.physics.secondquant.B[source]

+sympy.physics.secondquant.B[source]
 
alias of AnnihilateBoson

 

 
 

 

-sympy.physics.secondquant.BBra[source]

+sympy.physics.secondquant.BBra[source]
 
alias of FockStateBosonBra

 

 
 

 

-sympy.physics.secondquant.BKet[source]

+sympy.physics.secondquant.BKet[source]
 
alias of FockStateBosonKet

 

 
 

 

-sympy.physics.secondquant.Bd[source]

+sympy.physics.secondquant.Bd[source]
 
alias of CreateBoson

 

 
 

 

-class sympy.physics.secondquant.BosonicBasis[source]

+class sympy.physics.secondquant.BosonicBasis[source]
 
Base class for a basis set of bosonic Fock states.

 

 
 

 

-class sympy.physics.secondquant.Commutator(a, b)[source]

+class sympy.physics.secondquant.Commutator(a, b)[source]
 
The Commutator:  [A, B] = A*B - B*A

 
The arguments are ordered according to .__cmp__()

 
Examples

@@ -1087,7 +1087,7 @@ 
Documentation Version

 

 

 

-doit(**hints)[source]

+doit(**hints)[source]
 
Enables the computation of complex expressions.

 
Examples

 
>>> from sympy.physics.secondquant import Commutator, F, Fd
@@ -1103,7 +1103,7 @@ 
Documentation Version

 
 

 

-classmethod eval(a, b)[source]

+classmethod eval(a, b)[source]
 
The Commutator [A,B] is on canonical form if A < B.

 
Examples

 
>>> from sympy.physics.secondquant import Commutator, F, Fd
@@ -1120,11 +1120,11 @@ 
Documentation Version

 
 

 

-class sympy.physics.secondquant.CreateBoson(k)[source]

+class sympy.physics.secondquant.CreateBoson(k)[source]
 
Bosonic creation operator.

 

 

-apply_operator(state)[source]

+apply_operator(state)[source]
 
Apply state to self if self is not symbolic and state is a FockStateKet, else
 multiply self by state.

 
Examples

@@ -1142,11 +1142,11 @@ 
Documentation Version

 
 

 

-class sympy.physics.secondquant.CreateFermion(k)[source]

+class sympy.physics.secondquant.CreateFermion(k)[source]
 
Fermionic creation operator.

 

 

-apply_operator(state)[source]

+apply_operator(state)[source]
 
Apply state to self if self is not symbolic and state is a FockStateKet, else
 multiply self by state.

 
Examples

@@ -1254,7 +1254,7 @@ 
Documentation Version

 
 

 

-class sympy.physics.secondquant.Dagger(arg)[source]

+class sympy.physics.secondquant.Dagger(arg)[source]
 
Hermitian conjugate of creation/annihilation operators.

 
Examples

 
>>> from sympy import I
@@ -1269,7 +1269,7 @@ 
Documentation Version

 

 

 

-classmethod eval(arg)[source]

+classmethod eval(arg)[source]
 
Evaluates the Dagger instance.

 
Examples

 
>>> from sympy import I
@@ -1289,31 +1289,31 @@ 
Documentation Version

 
 

 

-sympy.physics.secondquant.F[source]

+sympy.physics.secondquant.F[source]
 
alias of AnnihilateFermion

 

 
 

 

-sympy.physics.secondquant.FBra[source]

+sympy.physics.secondquant.FBra[source]
 
alias of FockStateFermionBra

 

 
 

 

-sympy.physics.secondquant.FKet[source]

+sympy.physics.secondquant.FKet[source]
 
alias of FockStateFermionKet

 

 
 

 

-sympy.physics.secondquant.Fd[source]

+sympy.physics.secondquant.Fd[source]
 
alias of CreateFermion

 

 
 

 

-class sympy.physics.secondquant.FixedBosonicBasis(n_particles, n_levels)[source]

+class sympy.physics.secondquant.FixedBosonicBasis(n_particles, n_levels)[source]
 
Fixed particle number basis set.

 
Examples

 
>>> from sympy.physics.secondquant import FixedBosonicBasis
@@ -1329,7 +1329,7 @@ 
Documentation Version

 

 

 

-index(state)[source]

+index(state)[source]
 
Returns the index of state in basis.

 
Examples

 
>>> from sympy.physics.secondquant import FixedBosonicBasis
@@ -1342,7 +1342,7 @@ 
Documentation Version

 
 

 

-state(i)[source]

+state(i)[source]
 
Returns the state that lies at index i of the basis

 
Examples

 
>>> from sympy.physics.secondquant import FixedBosonicBasis
@@ -1357,7 +1357,7 @@ 
Documentation Version

 
 

 

-class sympy.physics.secondquant.FockState(occupations)[source]

+class sympy.physics.secondquant.FockState(occupations)[source]
 
Many particle Fock state with a sequence of occupation numbers.

 
Anywhere you can have a FockState, you can also have S.Zero.
 All code must check for this!

@@ -1366,7 +1366,7 @@ 
Documentation Version

 
 

 

-class sympy.physics.secondquant.FockStateBosonBra(occupations)[source]

+class sympy.physics.secondquant.FockStateBosonBra(occupations)[source]
 
Describes a collection of BosonBra particles.

 
Examples

 
>>> from sympy.physics.secondquant import BBra
@@ -1378,7 +1378,7 @@ 
Documentation Version

 
 

 

-class sympy.physics.secondquant.FockStateBosonKet(occupations)[source]

+class sympy.physics.secondquant.FockStateBosonKet(occupations)[source]
 
Many particle Fock state with a sequence of occupation numbers.

 
Occupation numbers can be any integer >= 0.

 
Examples

@@ -1391,13 +1391,13 @@ 
Documentation Version

 
 

 

-class sympy.physics.secondquant.FockStateBra(occupations)[source]

+class sympy.physics.secondquant.FockStateBra(occupations)[source]
 
Representation of a bra.

 

 
 

 

-class sympy.physics.secondquant.FockStateFermionBra(occupations, fermi_level=0)[source]

+class sympy.physics.secondquant.FockStateFermionBra(occupations, fermi_level=0)[source]
 
Examples

 
>>> from sympy.physics.secondquant import FBra
 >>> FBra([1, 2])
@@ -1412,7 +1412,7 @@ 
Documentation Version

 
 

 

-class sympy.physics.secondquant.FockStateFermionKet(occupations, fermi_level=0)[source]

+class sympy.physics.secondquant.FockStateFermionKet(occupations, fermi_level=0)[source]
 
Many-particle Fock state with a sequence of occupied orbits.

 
Explanation

 
Each state can only have one particle, so we choose to store a list of
@@ -1431,13 +1431,13 @@ 
Documentation Version

 
 

 

-class sympy.physics.secondquant.FockStateKet(occupations)[source]

+class sympy.physics.secondquant.FockStateKet(occupations)[source]
 
Representation of a ket.

 

 
 

 

-class sympy.physics.secondquant.InnerProduct(bra, ket)[source]

+class sympy.physics.secondquant.InnerProduct(bra, ket)[source]
 
An unevaluated inner product between a bra and ket.

 
Explanation

 
Currently this class just reduces things to a product of
@@ -1460,7 +1460,7 @@ 
Documentation Version

 
 

 

-class sympy.physics.secondquant.KroneckerDelta(i, j, delta_range=None)[source]

+class sympy.physics.secondquant.KroneckerDelta(i, j, delta_range=None)[source]
 
The discrete, or Kronecker, delta function.

 

 
Parameters:

@@ -1511,7 +1511,7 @@ 
Documentation Version

 

 

 

-classmethod eval(i, j, delta_range=None)[source]

+classmethod eval(i, j, delta_range=None)[source]
 
Evaluates the discrete delta function.

 
Examples

 
>>> from sympy import KroneckerDelta
@@ -1708,7 +1708,7 @@ 
Documentation Version

 
 

 

-class sympy.physics.secondquant.NO(arg)[source]

+class sympy.physics.secondquant.NO(arg)[source]
 
This Object is used to represent normal ordering brackets.

 
i.e.  {abcd}  sometimes written  :abcd:

 
Explanation

@@ -1733,7 +1733,7 @@ 
Documentation Version

 Nothing more, nothing less.

 

 

-doit(**hints)[source]

+doit(**hints)[source]
 
Either removes the brackets or enables complex computations
 in its arguments.

 
Examples

@@ -1754,7 +1754,7 @@ 
Documentation Version

 
 

 

-get_subNO(i)[source]

+get_subNO(i)[source]
 
Returns a NO() without FermionicOperator at index i.

 
Examples

 
>>> from sympy import symbols
@@ -1814,7 +1814,7 @@ 
Documentation Version

 
 

 

-iter_q_annihilators()[source]

+iter_q_annihilators()[source]
 
Iterates over the annihilation operators.

 
Examples

 
>>> from sympy import symbols
@@ -1836,7 +1836,7 @@ 
Documentation Version

 
 

 

-iter_q_creators()[source]

+iter_q_creators()[source]
 
Iterates over the creation operators.

 
Examples

 
>>> from sympy import symbols
@@ -1860,12 +1860,12 @@ 
Documentation Version

 
 

 

-class sympy.physics.secondquant.PermutationOperator(i, j)[source]

+class sympy.physics.secondquant.PermutationOperator(i, j)[source]
 
Represents the index permutation operator P(ij).

 
P(ij)*f(i)*g(j) = f(i)*g(j) - f(j)*g(i)

 

 

-get_permuted(expr)[source]

+get_permuted(expr)[source]
 
Returns -expr with permuted indices.

 
Explanation

 
>>> from sympy import symbols, Function
@@ -1882,7 +1882,7 @@ 
Documentation Version

 
 

 

-class sympy.physics.secondquant.VarBosonicBasis(n_max)[source]

+class sympy.physics.secondquant.VarBosonicBasis(n_max)[source]
 
A single state, variable particle number basis set.

 
Examples

 
>>> from sympy.physics.secondquant import VarBosonicBasis
@@ -1894,7 +1894,7 @@ 
Documentation Version

 

 

 

-index(state)[source]

+index(state)[source]
 
Returns the index of state in basis.

 
Examples

 
>>> from sympy.physics.secondquant import VarBosonicBasis
@@ -1912,7 +1912,7 @@ 
Documentation Version

 
 

 

-state(i)[source]

+state(i)[source]
 
The state of a single basis.

 
Examples

 
>>> from sympy.physics.secondquant import VarBosonicBasis
@@ -1927,7 +1927,7 @@ 
Documentation Version

 
 

 

-sympy.physics.secondquant.apply_operators(e)[source]

+sympy.physics.secondquant.apply_operators(e)[source]
 
Take a SymPy expression with operators and states and apply the operators.

 
Examples

 
>>> from sympy.physics.secondquant import apply_operators
@@ -1940,7 +1940,7 @@ 
Documentation Version

 
 

 

-sympy.physics.secondquant.contraction(a, b)[source]

+sympy.physics.secondquant.contraction(a, b)[source]
 
Calculates contraction of Fermionic operators a and b.

 
Examples

 
>>> from sympy import symbols
@@ -1977,7 +1977,7 @@ 
Documentation Version

 
 

 

-sympy.physics.secondquant.evaluate_deltas(e)[source]

+sympy.physics.secondquant.evaluate_deltas(e)[source]
 
We evaluate KroneckerDelta symbols in the expression assuming Einstein summation.

 
Explanation

 
If one index is repeated it is summed over and in effect substituted with
@@ -2037,7 +2037,7 @@ 
Documentation Version

 
 

 

-sympy.physics.secondquant.matrix_rep(op, basis)[source]

+sympy.physics.secondquant.matrix_rep(op, basis)[source]
 
Find the representation of an operator in a basis.

 
Examples

 
>>> from sympy.physics.secondquant import VarBosonicBasis, B, matrix_rep
@@ -2063,7 +2063,7 @@ 
Documentation Version

 
permutation_operators,

 

 
-)[source]
+)[source]
 
Performs simplification by introducing PermutationOperators where appropriate.

 
Explanation

 

@@ -2106,7 +2106,7 @@ 
Documentation Version

 
pretty_indices={},

 

 
-)[source]
+)[source]
 
Collect terms by substitution of dummy variables.

 
Explanation

 
This routine allows simplification of Add expressions containing terms
@@ -2165,7 +2165,7 @@ 
Documentation Version

 
 

 

-sympy.physics.secondquant.wicks(e, **kw_args)[source]

+sympy.physics.secondquant.wicks(e, **kw_args)[source]
 
Returns the normal ordered equivalent of an expression using Wicks Theorem.

 
Examples

 
>>> from sympy import symbols, Dummy
diff --git a/dev/modules/physics/sho.html b/dev/modules/physics/sho.html
index 9d9f19d12dd..e7f753f2d72 100644
--- a/dev/modules/physics/sho.html
+++ b/dev/modules/physics/sho.html
@@ -802,7 +802,7 @@ 
Documentation Version

 
Quantum Harmonic Oscillator in 3-D

 

 

-sympy.physics.sho.E_nl(n, l, hw)[source]

+sympy.physics.sho.E_nl(n, l, hw)[source]
 
Returns the Energy of an isotropic harmonic oscillator.

 

 
Parameters:

@@ -838,7 +838,7 @@ 
Documentation Version

 
 

 

-sympy.physics.sho.R_nl(n, l, nu, r)[source]

+sympy.physics.sho.R_nl(n, l, nu, r)[source]
 
Returns the radial wavefunction R_{nl} for a 3d isotropic harmonic
 oscillator.

 

diff --git a/dev/modules/physics/units/dimensions.html b/dev/modules/physics/units/dimensions.html
index c2bc7fbee52..7156b529c30 100644
--- a/dev/modules/physics/units/dimensions.html
+++ b/dev/modules/physics/units/dimensions.html
@@ -809,7 +809,7 @@ 
Documentation Version

 question of adding time to length has no meaning.

 

 

-class sympy.physics.units.dimensions.Dimension(name, symbol=None)[source]

+class sympy.physics.units.dimensions.Dimension(name, symbol=None)[source]
 
This class represent the dimension of a physical quantities.

 
The Dimension constructor takes as parameters a name and an optional
 symbol.

@@ -850,7 +850,7 @@ 
Documentation Version

 

 

 

-has_integer_powers(dim_sys)[source]

+has_integer_powers(dim_sys)[source]
 
Check if the dimension object has only integer powers.

 
All the dimension powers should be integers, but rational powers may
 appear in intermediate steps. This method may be used to check that the
@@ -869,7 +869,7 @@ 
Documentation Version

 
dimensional_dependencies={},

 

 
-)[source]
+)[source]
 
DimensionSystem represents a coherent set of dimensions.

 
The constructor takes three parameters:

 
    
@@ -902,7 +902,7 @@ 
    Documentation Version
    
 
 
    
 
    
-dim_can_vector(dim)[source]
    
+dim_can_vector(dim)[source]
 
    Useless method, kept for compatibility with previous versions.
    
 
    DO NOT USE.
    
 
    Dimensional representation in terms of the canonical base dimensions.
    
@@ -910,7 +910,7 @@ 
    Documentation Version
    
 
 
    
 
    
-dim_vector(dim)[source]
    
+dim_vector(dim)[source]
 
    Useless method, kept for compatibility with previous versions.
    
 
    DO NOT USE.
    
 
    Vector representation in terms of the base dimensions.
    
@@ -941,7 +941,7 @@ 
    Documentation Version
    
 
 
    
 
    
-is_dimensionless(dimension)[source]
    
+is_dimensionless(dimension)[source]
 
    Check if the dimension object really has a dimension.
    
 
    A dimension should have at least one component with non-zero power.
    
 
    
@@ -956,7 +956,7 @@ 
    Documentation Version
    
 
 
    
 
    
-print_dim_base(dim)[source]
    
+print_dim_base(dim)[source]
 
    Give the string expression of a dimension in term of the basis symbols.
    
 
    
 
diff --git a/dev/modules/physics/units/prefixes.html b/dev/modules/physics/units/prefixes.html
index 39d8c5045f0..706d225b56c 100644
--- a/dev/modules/physics/units/prefixes.html
+++ b/dev/modules/physics/units/prefixes.html
@@ -815,7 +815,7 @@ 
    Documentation Version
    
 
    latex_repr=None,
    
 
    
 
-)[source]
+)[source]
 
    This class represent prefixes, with their name, symbol and factor.
    
 
    Prefixes are used to create derived units from a given unit. They should
 always be encapsulated into units.
    
diff --git a/dev/modules/physics/units/quantities.html b/dev/modules/physics/units/quantities.html
index 8521f9092d4..19ad6d79e48 100644
--- a/dev/modules/physics/units/quantities.html
+++ b/dev/modules/physics/units/quantities.html
@@ -816,7 +816,7 @@ 
    Documentation Version
    
 
    **assumptions,
    
 
    
 
-)[source]
+)[source]
 
    Physical quantity: can be a unit of measure, a constant or a generic quantity.
    
 
    
 
    
@@ -827,7 +827,7 @@ 
    Documentation Version
    
 
 
    
 
    
-convert_to(other, unit_system='SI')[source]
    
+convert_to(other, unit_system='SI')[source]
    
 
    Convert the quantity to another quantity of same dimensions.
    
 
    Examples
    
 
    >>> from sympy.physics.units import speed_of_light, meter, second
@@ -871,7 +871,7 @@ 
    Documentation Version
    
 
    reference_quantity,
    
 
    
 
-)[source]
+)[source]
 
    Setting a scale factor that is valid across all unit system.
    
 

 
@@ -882,7 +882,7 @@ 
Documentation Version

 
Several methods to simplify expressions involving unit objects.

 

 

-sympy.physics.units.util.convert_to(expr, target_units, unit_system='SI')[source]

+sympy.physics.units.util.convert_to(expr, target_units, unit_system='SI')[source]
 
Convert expr to the same expression with all of its units and quantities
 represented as factors of target_units, whenever the dimension is compatible.

 
target_units may be a single unit/quantity, or a collection of
diff --git a/dev/modules/physics/units/unitsystem.html b/dev/modules/physics/units/unitsystem.html
index dfa3f1eb629..ebf78e92324 100644
--- a/dev/modules/physics/units/unitsystem.html
+++ b/dev/modules/physics/units/unitsystem.html
@@ -814,7 +814,7 @@ 
Documentation Version

 
derived_units: Dict[Dimension, Quantity] = {},

 

 
-)[source]
+)[source]
 
UnitSystem represents a coherent set of units.

 
A unit system is basically a dimension system with notions of scales. Many
 of the methods are defined in the same way.

@@ -839,7 +839,7 @@ 
Documentation Version

 
derived_units: Dict[Dimension, Quantity] = {},

 

 
-)[source]
+)[source]
 
Extend the current system into a new one.

 
Take the base and normal units of the current system to merge
 them to the base and normal units given in argument.
@@ -848,7 +848,7 @@ 
Documentation Version

 
 

 

-get_units_non_prefixed() → Set[Quantity][source]

+get_units_non_prefixed() → Set[Quantity][source]
 
Return the units of the system that do not have a prefix.

 

 
diff --git a/dev/modules/physics/vector/api/classes.html b/dev/modules/physics/vector/api/classes.html
index 0fe1afda059..06c7097e571 100644
--- a/dev/modules/physics/vector/api/classes.html
+++ b/dev/modules/physics/vector/api/classes.html
@@ -802,7 +802,7 @@ 
Documentation Version

 
Essential Classes

 

 

-class sympy.physics.vector.frame.CoordinateSym(name, frame, index)[source]

+class sympy.physics.vector.frame.CoordinateSym(name, frame, index)[source]
 
A coordinate symbol/base scalar associated wrt a Reference Frame.

 
Ideally, users should not instantiate this class. Instances of
 this class must only be accessed through the corresponding frame
@@ -850,7 +850,7 @@ 
Essential Classesvariables=None,

 

 
-)[source]
+)[source]
 
A reference frame in classical mechanics.

 
ReferenceFrame is a class used to represent a reference frame in classical
 mechanics. It has a standard basis of three unit vectors in the frame’s
@@ -861,7 +861,7 @@ 
Essential Classes
 

-ang_acc_in(otherframe)[source]

+ang_acc_in(otherframe)[source]
 
Returns the angular acceleration Vector of the ReferenceFrame.

 
Effectively returns the Vector:

 
N_alpha_B

@@ -889,7 +889,7 @@ 
Essential Classes
 

-ang_vel_in(otherframe)[source]

+ang_vel_in(otherframe)[source]
 
Returns the angular velocity Vector of the ReferenceFrame.

 
Effectively returns the Vector:

 
^N omega ^B

@@ -917,7 +917,7 @@ 
Essential Classes
 

-dcm(otherframe)[source]

+dcm(otherframe)[source]
 
Returns the direction cosine matrix of this reference frame
 relative to the provided reference frame.

 
The returned matrix can be used to express the orthogonal unit vectors
@@ -994,7 +994,7 @@ 
Essential Classesrot_order='',

 

 
-)[source]
+)[source]
 
Sets the orientation of this reference frame relative to another
 (parent) reference frame.

 

@@ -1057,7 +1057,7 @@ 
Essential Classes
 

-orient_axis(parent, axis, angle)[source]

+orient_axis(parent, axis, angle)[source]
 
Sets the orientation of this reference frame with respect to a
 parent reference frame by rotating through an angle about an axis fixed
 in the parent reference frame.

@@ -1131,7 +1131,7 @@ 
Essential Classesrotation_order,

 

 
-)[source]
+)[source]
 
Rotates this reference frame relative to the parent reference frame
 by right hand rotating through three successive body fixed simple axis
 rotations. Each subsequent axis of rotation is about the “body fixed”
@@ -1216,7 +1216,7 @@ 
Essential Classes
 

-orient_dcm(parent, dcm)[source]

+orient_dcm(parent, dcm)[source]
 
Sets the orientation of this reference frame relative to another (parent) reference frame
 using a direction cosine matrix that describes the rotation from the child to the parent.

 

@@ -1275,7 +1275,7 @@ 
Essential Classes
 

-orient_quaternion(parent, numbers)[source]

+orient_quaternion(parent, numbers)[source]
 
Sets the orientation of this reference frame relative to a parent
 reference frame via an orientation quaternion. An orientation
 quaternion is defined as a finite rotation a unit vector, (lambda_x,
@@ -1339,7 +1339,7 @@ 
Essential Classesrotation_order,

 

 
-)[source]
+)[source]
 
Rotates this reference frame relative to the parent reference frame
 by right hand rotating through three successive space fixed simple axis
 rotations. Each subsequent axis of rotation is about the “space fixed”
@@ -1439,7 +1439,7 @@ 
Essential Classeslatexs=None,

 

 
-)[source]
+)[source]
 
Returns a new reference frame oriented with respect to this
 reference frame.

 
See ReferenceFrame.orient() for detailed examples of how to orient
@@ -1538,7 +1538,7 @@ 
Essential Classes*gen_speeds,

 

 
-)[source]
+)[source]
 
Returns the partial angular velocities of this frame in the given
 frame with respect to one or more provided generalized speeds.

 

@@ -1576,7 +1576,7 @@ 
Essential Classes
 

-set_ang_acc(otherframe, value)[source]

+set_ang_acc(otherframe, value)[source]
 
Define the angular acceleration Vector in a ReferenceFrame.

 
Defines the angular acceleration of this ReferenceFrame, in another.
 Angular acceleration can be defined with respect to multiple different
@@ -1608,7 +1608,7 @@ 
Essential Classes
 

-set_ang_vel(otherframe, value)[source]

+set_ang_vel(otherframe, value)[source]
 
Define the angular velocity vector in a ReferenceFrame.

 
Defines the angular velocity of this ReferenceFrame, in another.
 Angular velocity can be defined with respect to multiple different
@@ -1646,7 +1646,7 @@ 
Essential Classes
 

-variable_map(otherframe)[source]

+variable_map(otherframe)[source]
 
Returns a dictionary which expresses the coordinate variables
 of this frame in terms of the variables of otherframe.

 
If Vector.simp is True, returns a simplified version of the mapped
@@ -1747,7 +1747,7 @@ 
Essential Classes
 

-class sympy.physics.vector.vector.Vector(inlist)[source]

+class sympy.physics.vector.vector.Vector(inlist)[source]
 
The class used to define vectors.

 
It along with ReferenceFrame are the building blocks of describing a
 classical mechanics system in PyDy and sympy.physics.vector.

@@ -1763,7 +1763,7 @@ 
Essential Classes
 

-angle_between(vec)[source]

+angle_between(vec)[source]
 
Returns the smallest angle between Vector ‘vec’ and self.

 

 
Warning

@@ -1794,13 +1794,13 @@ 
Essential Classes
 

-applyfunc(f)[source]

+applyfunc(f)[source]
 
Apply a function to each component of a vector.

 

 
 

 

-cross(other)[source]

+cross(other)[source]
 
The cross product operator for two Vectors.

 
Returns a Vector, expressed in the same ReferenceFrames as self.

 

@@ -1830,7 +1830,7 @@ 
Essential Classes
 

-diff(var, frame, var_in_dcm=True)[source]

+diff(var, frame, var_in_dcm=True)[source]
 
Returns the partial derivative of the vector with respect to a
 variable in the provided reference frame.

 

@@ -1878,13 +1878,13 @@ 
Essential Classes
 

-doit(**hints)[source]

+doit(**hints)[source]
 
Calls .doit() on each term in the Vector

 

 
 

 

-dot(other)[source]

+dot(other)[source]
 
Dot product of two vectors.

 
Returns a scalar, the dot product of the two Vectors

 

@@ -1913,7 +1913,7 @@ 
Essential Classes
 

-dt(otherframe)[source]

+dt(otherframe)[source]
 
Returns a Vector which is the time derivative of
 the self Vector, taken in frame otherframe.

 
Calls the global time_derivative method

@@ -1929,7 +1929,7 @@ 
Essential Classes
 

-express(otherframe, variables=False)[source]

+express(otherframe, variables=False)[source]
 
Returns a Vector equivalent to this one, expressed in otherframe.
 Uses the global express method.

 

@@ -1960,7 +1960,7 @@ 
Essential Classes
 

-free_dynamicsymbols(reference_frame)[source]

+free_dynamicsymbols(reference_frame)[source]
 
Returns the free dynamic symbols (functions of time t) in the
 measure numbers of the vector expressed in the given reference frame.

 

@@ -1983,7 +1983,7 @@ 
Essential Classes
 

-free_symbols(reference_frame)[source]

+free_symbols(reference_frame)[source]
 
Returns the free symbols in the measure numbers of the vector
 expressed in the given reference frame.

 

@@ -2012,7 +2012,7 @@ 
Essential Classes
 

-magnitude()[source]

+magnitude()[source]
 
Returns the magnitude (Euclidean norm) of self.

 

 
Warning

@@ -2025,13 +2025,13 @@ 
Essential Classes
 

-normalize()[source]

+normalize()[source]
 
Returns a Vector of magnitude 1, codirectional with self.

 

 
 

 

-outer(other)[source]

+outer(other)[source]
 
Outer product between two Vectors.

 
A rank increasing operation, which returns a Dyadic from two Vectors

 

@@ -2053,7 +2053,7 @@ 
Essential Classes
 

-separate()[source]

+separate()[source]
 
The constituents of this vector in different reference frames,
 as per its definition.

 
Returns a dict mapping each ReferenceFrame to the corresponding
@@ -2071,13 +2071,13 @@ 
Essential Classes
 

-simplify()[source]

+simplify()[source]
 
Returns a simplified Vector.

 

 
 

 

-subs(*args, **kwargs)[source]

+subs(*args, **kwargs)[source]
 
Substitution on the Vector.

 
Examples

 
>>> from sympy.physics.vector import ReferenceFrame
@@ -2093,7 +2093,7 @@ 
Essential Classes
 

-to_matrix(reference_frame)[source]

+to_matrix(reference_frame)[source]
 
Returns the matrix form of the vector with respect to the given
 frame.

 

@@ -2134,7 +2134,7 @@ 
Essential Classes
 

-xreplace(rule)[source]

+xreplace(rule)[source]
 
Replace occurrences of objects within the measure numbers of the
 vector.

 

@@ -2176,7 +2176,7 @@ 
Essential Classes
 

-class sympy.physics.vector.dyadic.Dyadic(inlist)[source]

+class sympy.physics.vector.dyadic.Dyadic(inlist)[source]
 
A Dyadic object.

 
See:
 https://en.wikipedia.org/wiki/Dyadic_tensor
@@ -2186,13 +2186,13 @@ 
Essential Classes
 

-applyfunc(f)[source]

+applyfunc(f)[source]
 
Apply a function to each component of a Dyadic.

 

 
 

 

-cross(other)[source]

+cross(other)[source]
 
Returns the dyadic resulting from the dyadic vector cross product:
 Dyadic x Vector.

 

@@ -2215,13 +2215,13 @@ 
Essential Classes
 

-doit(**hints)[source]

+doit(**hints)[source]
 
Calls .doit() on each term in the Dyadic

 

 
 

 

-dot(other)[source]

+dot(other)[source]
 
The inner product operator for a Dyadic and a Dyadic or Vector.

 

 
Parameters:

@@ -2246,7 +2246,7 @@ 
Essential Classes
 

-dt(frame)[source]

+dt(frame)[source]
 
Take the time derivative of this Dyadic in a frame.

 
This function calls the global time_derivative method

 

@@ -2273,7 +2273,7 @@ 
Essential Classes
 

-express(frame1, frame2=None)[source]

+express(frame1, frame2=None)[source]
 
Expresses this Dyadic in alternate frame(s)

 
The first frame is the list side expression, the second frame is the
 right side; if Dyadic is in form A.x|B.y, you can express it in two
@@ -2314,13 +2314,13 @@ 
Essential Classes
 

-simplify()[source]

+simplify()[source]
 
Returns a simplified Dyadic.

 

 
 

 

-subs(*args, **kwargs)[source]

+subs(*args, **kwargs)[source]
 
Substitution on the Dyadic.

 
Examples

 
>>> from sympy.physics.vector import ReferenceFrame
@@ -2343,7 +2343,7 @@ 
Essential Classessecond_reference_frame=None,

 

 
-)[source]
+)[source]
 
Returns the matrix form of the dyadic with respect to one or two
 reference frames.

 

@@ -2392,7 +2392,7 @@ 
Essential Classes
 

-xreplace(rule)[source]

+xreplace(rule)[source]
 
Replace occurrences of objects within the measure numbers of the
 Dyadic.

 

diff --git a/dev/modules/physics/vector/api/fieldfunctions.html b/dev/modules/physics/vector/api/fieldfunctions.html
index 170ce9ab4b9..6e17c51bfbd 100644
--- a/dev/modules/physics/vector/api/fieldfunctions.html
+++ b/dev/modules/physics/vector/api/fieldfunctions.html
@@ -806,7 +806,7 @@ 
Field operation functions
 

-sympy.physics.vector.fieldfunctions.curl(vect, frame)[source]

+sympy.physics.vector.fieldfunctions.curl(vect, frame)[source]
 
Returns the curl of a vector field computed wrt the coordinate
 symbols of the given frame.

 

@@ -837,7 +837,7 @@ 
Field operation functions
 

-sympy.physics.vector.fieldfunctions.divergence(vect, frame)[source]

+sympy.physics.vector.fieldfunctions.divergence(vect, frame)[source]
 
Returns the divergence of a vector field computed wrt the coordinate
 symbols of the given frame.

 

@@ -868,7 +868,7 @@ 
Field operation functions
 

-sympy.physics.vector.fieldfunctions.gradient(scalar, frame)[source]

+sympy.physics.vector.fieldfunctions.gradient(scalar, frame)[source]
 
Returns the vector gradient of a scalar field computed wrt the
 coordinate symbols of the given frame.

 

@@ -899,7 +899,7 @@ 
Field operation functions
 

-sympy.physics.vector.fieldfunctions.scalar_potential(field, frame)[source]

+sympy.physics.vector.fieldfunctions.scalar_potential(field, frame)[source]
 
Returns the scalar potential function of a field in a given frame
 (without the added integration constant).

 

@@ -941,7 +941,7 @@ 
Field operation functionsorigin,

 

 
-)[source]
+)[source]
 
Returns the scalar potential difference between two points in a
 certain frame, wrt a given field.

 
If a scalar field is provided, its values at the two points are
@@ -994,7 +994,7 @@ 
Field operation functions

 

 

-sympy.physics.vector.fieldfunctions.is_conservative(field)[source]

+sympy.physics.vector.fieldfunctions.is_conservative(field)[source]
 
Checks if a field is conservative.

 

 
Parameters:

@@ -1018,7 +1018,7 @@ 
Checking the type of vector field
 

-sympy.physics.vector.fieldfunctions.is_solenoidal(field)[source]

+sympy.physics.vector.fieldfunctions.is_solenoidal(field)[source]
 
Checks if a field is solenoidal.

 

 
Parameters:

diff --git a/dev/modules/physics/vector/api/functions.html b/dev/modules/physics/vector/api/functions.html
index 6c4a26f433e..bd936d51b46 100644
--- a/dev/modules/physics/vector/api/functions.html
+++ b/dev/modules/physics/vector/api/functions.html
@@ -802,7 +802,7 @@ 
Documentation Version

 
Essential Functions (Docstrings)

 

 

-sympy.physics.vector.dynamicsymbols(names, level=0, **assumptions)[source]

+sympy.physics.vector.dynamicsymbols(names, level=0, **assumptions)[source]
 
Uses symbols and Function for functions of time.

 
Creates a SymPy UndefinedFunction, which is then initialized as a function
 of a variable, the default being Symbol(‘t’).

@@ -871,7 +871,7 @@ 
Essential Functions (Docstrings)
 

-sympy.physics.vector.functions.dot(vec1, vec2)[source]

+sympy.physics.vector.functions.dot(vec1, vec2)[source]
 
Dot product convenience wrapper for Vector.dot(): 
 Dot product of two vectors.

 

@@ -903,7 +903,7 @@ 
Essential Functions (Docstrings)
 

-sympy.physics.vector.functions.cross(vec1, vec2)[source]

+sympy.physics.vector.functions.cross(vec1, vec2)[source]
 
Cross product convenience wrapper for Vector.cross(): 
 The cross product operator for two Vectors.

 

@@ -936,7 +936,7 @@ 
Essential Functions (Docstrings)
 

-sympy.physics.vector.functions.outer(vec1, vec2)[source]

+sympy.physics.vector.functions.outer(vec1, vec2)[source]
 
Outer product convenience wrapper for Vector.outer():
 Outer product between two Vectors.

 

@@ -961,7 +961,7 @@ 
Essential Functions (Docstrings)
 

-sympy.physics.vector.functions.express(expr, frame, frame2=None, variables=False)[source]

+sympy.physics.vector.functions.express(expr, frame, frame2=None, variables=False)[source]
 
Global function for ‘express’ functionality.

 
Re-expresses a Vector, scalar(sympyfiable) or Dyadic in given frame.

 
Refer to the local methods of Vector and Dyadic for details.
@@ -1011,7 +1011,7 @@ 
Essential Functions (Docstrings)
 

-sympy.physics.vector.functions.time_derivative(expr, frame, order=1)[source]

+sympy.physics.vector.functions.time_derivative(expr, frame, order=1)[source]
 
Calculate the time derivative of a vector/scalar field function
 or dyadic expression in given frame.

 

diff --git a/dev/modules/physics/vector/api/kinematics.html b/dev/modules/physics/vector/api/kinematics.html
index 2327a3c7c04..057f884e61d 100644
--- a/dev/modules/physics/vector/api/kinematics.html
+++ b/dev/modules/physics/vector/api/kinematics.html
@@ -802,7 +802,7 @@ 
Documentation Version

 
Kinematics (Docstrings)

 

 

-class sympy.physics.vector.point.Point(name)[source]

+class sympy.physics.vector.point.Point(name)[source]
 
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 distance from a parent
@@ -855,7 +855,7 @@ 
Documentation Version

 
interframe,

 

 
-)[source]
+)[source]
 
Sets the acceleration of this point with the 1-point theory.

 
The 1-point theory for point acceleration looks like this:

 
^N a^P = ^B a^P + ^N a^O + ^N alpha^B x r^OP + ^N omega^B x (^N omega^B
@@ -910,7 +910,7 @@ 
Documentation Version

 
fixedframe,

 

 
-)[source]
+)[source]
 
Sets the acceleration of this point with the 2-point theory.

 
The 2-point theory for point acceleration looks like this:

 
^N a^P = ^N a^O + ^N alpha^B x r^OP + ^N omega^B x (^N omega^B x r^OP)

@@ -951,7 +951,7 @@ 
Documentation Version

 
 

 

-acc(frame)[source]

+acc(frame)[source]
 
The acceleration Vector of this Point in a ReferenceFrame.

 

 
Parameters:

@@ -975,7 +975,7 @@ 
Documentation Version

 
 

 

-locatenew(name, value)[source]

+locatenew(name, value)[source]
 
Creates a new point with a position defined from this point.

 

 
Parameters:

@@ -1000,7 +1000,7 @@ 
Documentation Version

 
 

 

-partial_velocity(frame, *gen_speeds)[source]

+partial_velocity(frame, *gen_speeds)[source]
 
Returns the partial velocities of the linear velocity vector of this
 point in the given frame with respect to one or more provided
 generalized speeds.

@@ -1041,7 +1041,7 @@ 
Documentation Version

 
 

 

-pos_from(otherpoint)[source]

+pos_from(otherpoint)[source]
 
Returns a Vector distance between this Point and the other Point.

 

 
Parameters:

@@ -1065,7 +1065,7 @@ 
Documentation Version

 
 

 

-set_acc(frame, value)[source]

+set_acc(frame, value)[source]
 
Used to set the acceleration of this Point in a ReferenceFrame.

 

 
Parameters:

@@ -1092,7 +1092,7 @@ 
Documentation Version

 
 

 

-set_pos(otherpoint, value)[source]

+set_pos(otherpoint, value)[source]
 
Used to set the position of this point w.r.t. another point.

 

 
Parameters:

@@ -1120,7 +1120,7 @@ 
Documentation Version

 
 

 

-set_vel(frame, value)[source]

+set_vel(frame, value)[source]
 
Sets the velocity Vector of this Point in a ReferenceFrame.

 

 
Parameters:

@@ -1155,7 +1155,7 @@ 
Documentation Version

 
interframe,

 

 
-)[source]
+)[source]
 
Sets the velocity of this point with the 1-point theory.

 
The 1-point theory for point velocity looks like this:

 
^N v^P = ^B v^P + ^N v^O + ^N omega^B x r^OP

@@ -1209,7 +1209,7 @@ 
Documentation Version

 
fixedframe,

 

 
-)[source]
+)[source]
 
Sets the velocity of this point with the 2-point theory.

 
The 2-point theory for point velocity looks like this:

 
^N v^P = ^N v^O + ^N omega^B x r^OP

@@ -1250,7 +1250,7 @@ 
Documentation Version

 
 

 

-vel(frame)[source]

+vel(frame)[source]
 
The velocity Vector of this Point in the ReferenceFrame.

 

 
Parameters:

@@ -1293,7 +1293,7 @@ 
Documentation Version

 
kinematic_equations

 

 

-sympy.physics.vector.functions.get_motion_params(frame, **kwargs)[source]

+sympy.physics.vector.functions.get_motion_params(frame, **kwargs)[source]
 
Returns the three motion parameters - (acceleration, velocity, and
 position) as vectorial functions of time in the given frame.

 
If a higher order differential function is provided, the lower order
@@ -1374,7 +1374,7 @@ 
Documentation Version

 
rot_order='',

 

 
-)[source]
+)[source]
 
Gives equations relating the qdot’s to u’s for a rotation type.

 
Supply rotation type and order as in orient. Speeds are assumed to be
 body-fixed; if we are defining the orientation of B in A using by rot_type,
@@ -1415,7 +1415,7 @@ 
Documentation Version

 
 

 

-sympy.physics.vector.functions.partial_velocity(vel_vecs, gen_speeds, frame)[source]

+sympy.physics.vector.functions.partial_velocity(vel_vecs, gen_speeds, frame)[source]
 
Returns a list of partial velocities with respect to the provided
 generalized speeds in the given reference frame for each of the supplied
 velocity vectors.

diff --git a/dev/modules/physics/vector/api/printing.html b/dev/modules/physics/vector/api/printing.html
index b630aa44e77..65fc888dae4 100644
--- a/dev/modules/physics/vector/api/printing.html
+++ b/dev/modules/physics/vector/api/printing.html
@@ -802,7 +802,7 @@ 
Documentation Version

 
Printing (Docstrings)

 

 

-sympy.physics.vector.printing.init_vprinting(**kwargs)[source]

+sympy.physics.vector.printing.init_vprinting(**kwargs)[source]
 
Initializes time derivative printing for all SymPy objects, i.e. any
 functions of time will be displayed in a more compact notation. The main
 benefit of this is for printing of time derivatives; instead of
@@ -950,7 +950,7 @@ 
Printing (Docstrings)
 

-sympy.physics.vector.printing.vprint(expr, **settings)[source]

+sympy.physics.vector.printing.vprint(expr, **settings)[source]
 
Function for printing of expressions generated in the
 sympy.physics vector package.

 
Extends SymPy’s StrPrinter, takes the same setting accepted by SymPy’s
@@ -980,7 +980,7 @@ 
Printing (Docstrings)
 

-sympy.physics.vector.printing.vpprint(expr, **settings)[source]

+sympy.physics.vector.printing.vpprint(expr, **settings)[source]
 
Function for pretty printing of expressions generated in the
 sympy.physics vector package.

 
Mainly used for expressions not inside a vector; the output of running
@@ -1002,7 +1002,7 @@ 
Printing (Docstrings)
 

-sympy.physics.vector.printing.vlatex(expr, **settings)[source]

+sympy.physics.vector.printing.vlatex(expr, **settings)[source]
 
Function for printing latex representation of sympy.physics.vector
 objects.

 
For latex representation of Vectors, Dyadics, and dynamicsymbols. Takes the
diff --git a/dev/modules/physics/wigner.html b/dev/modules/physics/wigner.html
index 500b5658ba4..ad359586dcd 100644
--- a/dev/modules/physics/wigner.html
+++ b/dev/modules/physics/wigner.html
@@ -868,7 +868,7 @@ 
Authors

 

-sympy.physics.wigner.clebsch_gordan(j_1, j_2, j_3, m_1, m_2, m_3)[source]

+sympy.physics.wigner.clebsch_gordan(j_1, j_2, j_3, m_1, m_2, m_3)[source]
 
Calculates the Clebsch-Gordan coefficient.
 \(\left\langle j_1 m_1 \; j_2 m_2 | j_3 m_3 \right\rangle\).

 
The reference for this function is [Edmonds74].

@@ -913,7 +913,7 @@ 
Authors

 

-sympy.physics.wigner.dot_rot_grad_Ynm(j, p, l, m, theta, phi)[source]

+sympy.physics.wigner.dot_rot_grad_Ynm(j, p, l, m, theta, phi)[source]
 
Returns dot product of rotational gradients of spherical harmonics.

 
Explanation

 
This function returns the right hand side of the following expression:

@@ -938,7 +938,7 @@ 
Authors

 

-sympy.physics.wigner.gaunt(l_1, l_2, l_3, m_1, m_2, m_3, prec=None)[source]

+sympy.physics.wigner.gaunt(l_1, l_2, l_3, m_1, m_2, m_3, prec=None)[source]
 
Calculate the Gaunt coefficient.

 

 
Parameters:

@@ -1033,7 +1033,7 @@ 
Authors

 

-sympy.physics.wigner.racah(aa, bb, cc, dd, ee, ff, prec=None)[source]

+sympy.physics.wigner.racah(aa, bb, cc, dd, ee, ff, prec=None)[source]
 
Calculate the Racah symbol \(W(a,b,c,d;e,f)\).

 

 
Parameters:

@@ -1093,7 +1093,7 @@ 
Authors
prec=None,

 

 
-)[source]
+)[source]
 
Calculate the real Gaunt coefficient.

 

 
Parameters:

@@ -1209,7 +1209,7 @@ 
Authors

 

-sympy.physics.wigner.wigner_3j(j_1, j_2, j_3, m_1, m_2, m_3)[source]

+sympy.physics.wigner.wigner_3j(j_1, j_2, j_3, m_1, m_2, m_3)[source]
 
Calculate the Wigner 3j symbol \(\operatorname{Wigner3j}(j_1,j_2,j_3,m_1,m_2,m_3)\).

 

 
Parameters:

@@ -1292,7 +1292,7 @@ 
Authors

 

-sympy.physics.wigner.wigner_6j(j_1, j_2, j_3, j_4, j_5, j_6, prec=None)[source]

+sympy.physics.wigner.wigner_6j(j_1, j_2, j_3, j_4, j_5, j_6, prec=None)[source]
 
Calculate the Wigner 6j symbol \(\operatorname{Wigner6j}(j_1,j_2,j_3,j_4,j_5,j_6)\).

 

 
Parameters:

@@ -1396,7 +1396,7 @@ 
Authors
prec=None,

 

 
-)[source]
+)[source]
 
Calculate the Wigner 9j symbol
 \(\operatorname{Wigner9j}(j_1,j_2,j_3,j_4,j_5,j_6,j_7,j_8,j_9)\).

 

@@ -1448,7 +1448,7 @@ 
Authors

 

-sympy.physics.wigner.wigner_d(J, alpha, beta, gamma)[source]

+sympy.physics.wigner.wigner_d(J, alpha, beta, gamma)[source]
 
Return the Wigner D matrix for angular momentum J.

 

 
Returns:

@@ -1498,7 +1498,7 @@ 
Authors

 

-sympy.physics.wigner.wigner_d_small(J, beta)[source]

+sympy.physics.wigner.wigner_d_small(J, beta)[source]
 
Return the small Wigner d matrix for angular momentum J.

 

 
Returns:

diff --git a/dev/modules/plotting.html b/dev/modules/plotting.html
index 2ed920055ba..5258f3bd65c 100644
--- a/dev/modules/plotting.html
+++ b/dev/modules/plotting.html
@@ -850,7 +850,7 @@ 
Plot Class**kwargs,

 

 
-)[source]
+)[source]
 
Base class for all backends. A backend represents the plotting library,
 which implements the necessary functionalities in order to use SymPy
 plotting functions.

@@ -1007,7 +1007,7 @@ 
Plot Class
 

-append(arg)[source]

+append(arg)[source]
 
Adds an element from a plot’s series to an existing plot.

 
Examples

 
Consider two Plot objects, p1 and p2. To add the
@@ -1038,7 +1038,7 @@ 
Plot Class
 

-extend(arg)[source]

+extend(arg)[source]
 
Adds all series from another plot.

 
Examples

 
Consider two Plot objects, p1 and p2. To add the
@@ -1094,7 +1094,7 @@ 
Plot Class

 

 

-sympy.plotting.plot.plot(*args, show=True, **kwargs)[source]

+sympy.plotting.plot.plot(*args, show=True, **kwargs)[source]
 
Plots a function of a single variable as a curve.

 

 
Parameters:

@@ -1303,7 +1303,7 @@ 
Plotting Function Reference
 

-sympy.plotting.plot.plot_parametric(*args, show=True, **kwargs)[source]

+sympy.plotting.plot.plot_parametric(*args, show=True, **kwargs)[source]
 
Plots a 2D parametric curve.

 

 
Parameters:

@@ -1488,7 +1488,7 @@ 
Plotting Function Reference
 

-sympy.plotting.plot.plot3d(*args, show=True, **kwargs)[source]

+sympy.plotting.plot.plot3d(*args, show=True, **kwargs)[source]
 
Plots a 3D surface plot.

 
Usage

 
Single plot

@@ -1587,7 +1587,7 @@ 
Plotting Function Reference
 

-sympy.plotting.plot.plot3d_parametric_line(*args, show=True, **kwargs)[source]

+sympy.plotting.plot.plot3d_parametric_line(*args, show=True, **kwargs)[source]
 
Plots a 3D parametric line plot.

 
Usage

 
Single plot:

@@ -1681,7 +1681,7 @@ 
Plotting Function Reference**kwargs,

 

 
-)[source]
+)[source]
 
Plots a 3D parametric surface plot.

 
Explanation

 
Single plot.

@@ -1771,7 +1771,7 @@ 
Plotting Function Reference**kwargs,

 

 
-)[source]
+)[source]
 
A plot function to plot implicit equations / inequalities.

 
Arguments

 
    
@@ -1930,7 +1930,7 @@ 
    PlotGrid Class**kwargs,

 

 
-)[source]
+)[source]
 
This class helps to plot subplots from already created SymPy plots
 in a single figure.

 
Examples

@@ -2026,7 +2026,7 @@ 
PlotGrid Class

 

 

-class sympy.plotting.series.BaseSeries(*args, **kwargs)[source]

+class sympy.plotting.series.BaseSeries(*args, **kwargs)[source]
 
Base class for the data objects containing stuff to be plotted.

 
Notes

 
The backend should check if it supports the data series that is given.
@@ -2041,7 +2041,7 @@ 
Series Classes
 

-eval_color_func(*args)[source]

+eval_color_func(*args)[source]
 
Evaluate the color function.

 

 
Parameters:

@@ -2067,7 +2067,7 @@ 
Series Classes
 

-get_data()[source]

+get_data()[source]
 
Compute and returns the numerical data.

 
The number of parameters returned by this method depends on the
 specific instance. If s is the series, make sure to read
@@ -2083,7 +2083,7 @@ 
Series Classeswrapper='$%s$',

 

 
-)[source]
+)[source]
 
Return the label to be used to display the expression.

 

 
Parameters:

@@ -2131,7 +2131,7 @@ 
Series Classes
 

-class sympy.plotting.series.Line2DBaseSeries(**kwargs)[source]

+class sympy.plotting.series.Line2DBaseSeries(**kwargs)[source]
 
A base class for 2D lines.

 
    
 
  • adding the label, steps and only_integers options
    • 
@@ -2140,7 +2140,7 @@ 
    Series Classes
 
    
-get_data()[source]
    
+get_data()[source]
 
    Return coordinates for plotting the line.
    
 
    
 
    Returns:
    
@@ -2180,11 +2180,11 @@ 
    Series Classes**kwargs,
    
 

 
-)[source]
+)[source]
 
Representation for a line consisting of a SymPy expression over a range.

 

 

-get_points()[source]

+get_points()[source]
 
Return lists of coordinates for plotting. Depending on the
 adaptive option, this function will either use an adaptive algorithm
 or it will uniformly sample the expression over the provided range.

@@ -2220,14 +2220,14 @@ 
Series Classes**kwargs,

 

 
-)[source]
+)[source]
 
Representation for a line consisting of two parametric SymPy expressions
 over a range.

 

 
 

 

-class sympy.plotting.series.Line3DBaseSeries[source]

+class sympy.plotting.series.Line3DBaseSeries[source]
 
A base class for 3D lines.

 
Most of the stuff is derived from Line2DBaseSeries.

 

@@ -2245,14 +2245,14 @@ 
Series Classes**kwargs,

 

 
-)[source]
+)[source]
 
Representation for a 3D line consisting of three parametric SymPy
 expressions and a range.

 

 
 

 

-class sympy.plotting.series.SurfaceBaseSeries(*args, **kwargs)[source]

+class sympy.plotting.series.SurfaceBaseSeries(*args, **kwargs)[source]
 
A base class for 3D surfaces.

 

 
@@ -2268,12 +2268,12 @@ 
Series Classes**kwargs,

 

 
-)[source]
+)[source]
 
Representation for a 3D surface consisting of a SymPy expression and 2D
 range.

 

 

-get_data()[source]

+get_data()[source]
 
Return arrays of coordinates for plotting.

 

 
Returns:

@@ -2295,7 +2295,7 @@ 
Series Classes
 

-get_meshes()[source]

+get_meshes()[source]
 
Return the x,y,z coordinates for plotting the surface.
 This function is available for back-compatibility purposes. Consider
 using get_data() instead.

@@ -2317,12 +2317,12 @@ 
Series Classes**kwargs,

 

 
-)[source]
+)[source]
 
Representation for a 3D surface consisting of three parametric SymPy
 expressions and a range.

 

 

-get_data()[source]

+get_data()[source]
 
Return arrays of coordinates for plotting.

 

 
Returns:

@@ -2352,7 +2352,7 @@ 
Series Classes
 

-get_meshes()[source]

+get_meshes()[source]
 
Return the x,y,z coordinates for plotting the surface.
 This function is available for back-compatibility purposes. Consider
 using get_data() instead.

@@ -2372,11 +2372,11 @@ 
Series Classes**kwargs,

 

 
-)[source]
+)[source]
 
Representation for 2D Implicit plot.

 

 

-get_data()[source]

+get_data()[source]
 
Returns numerical data.

 

 
Returns:

@@ -2413,7 +2413,7 @@ 
Series Classeswrapper='$%s$',

 

 
-)[source]
+)[source]
 
Return the label to be used to display the expression.

 

 
Parameters:

@@ -2441,12 +2441,12 @@ 
Series Classes

 

 

-class sympy.plotting.plot.MatplotlibBackend(*series, **kwargs)[source]

+class sympy.plotting.plot.MatplotlibBackend(*series, **kwargs)[source]
 
This class implements the functionalities to use Matplotlib with SymPy
 plotting functions.

 

 

-static get_segments(x, y, z=None)[source]

+static get_segments(x, y, z=None)[source]
 
Convert two list of coordinates to a list of segments to be used
 with Matplotlib’s LineCollection.

 

@@ -2469,7 +2469,7 @@ 
Backends
 
 

 

-process_series()[source]

+process_series()[source]
 
Iterates over every Plot object and further calls
 _process_series()

 

@@ -2478,7 +2478,7 @@ 
Backends
 
 

 

-class sympy.plotting.plot.TextBackend(*args, **kwargs)[source]

+class sympy.plotting.plot.TextBackend(*args, **kwargs)[source]
 

 
 
@@ -2712,7 +2712,7 @@ 
Using Custom Color Functions

 

 

-sympy.plotting.textplot.textplot(expr, a, b, W=55, H=21)[source]

+sympy.plotting.textplot.textplot(expr, a, b, W=55, H=21)[source]
 
Print a crude ASCII art plot of the SymPy expression ‘expr’ (which
 should contain a single symbol, e.g. x or something else) over the
 interval [a, b].

diff --git a/dev/modules/polys/agca.html b/dev/modules/polys/agca.html
index 346375f5544..cb2eb581ad5 100644
--- a/dev/modules/polys/agca.html
+++ b/dev/modules/polys/agca.html
@@ -900,11 +900,11 @@ 
Base Rings
 

-class sympy.polys.domains.ring.Ring[source]

+class sympy.polys.domains.ring.Ring[source]
 
Represents a ring domain.

 

 

-free_module(rank)[source]

+free_module(rank)[source]
 
Generate a free module of rank rank over self.

 
>>> from sympy.abc import x
 >>> from sympy import QQ
@@ -916,7 +916,7 @@ 
Base Rings
 

-ideal(*gens)[source]

+ideal(*gens)[source]
 
Generate an ideal of self.

 
>>> from sympy.abc import x
 >>> from sympy import QQ
@@ -928,7 +928,7 @@ 
Base Rings
 

-quotient_ring(e)[source]

+quotient_ring(e)[source]
 
Form a quotient ring of self.

 
Here e can be an ideal or an iterable.

 
>>> from sympy.abc import x
@@ -958,13 +958,13 @@ 
Base Ringsorder=None,

 

 
-)[source]
+)[source]
 
A class for representing multivariate polynomial rings.

 

 
 

 

-class sympy.polys.domains.quotientring.QuotientRing(ring, ideal)[source]

+class sympy.polys.domains.quotientring.QuotientRing(ring, ideal)[source]
 
Class representing (commutative) quotient rings.

 
You should not usually instantiate this by hand, instead use the constructor
 from the base ring in the construction.

@@ -1044,7 +1044,7 @@ 
Modules, Ideals and their Elementary Properties
 

-class sympy.polys.agca.modules.Module(ring)[source]

+class sympy.polys.agca.modules.Module(ring)[source]
 
Abstract base class for modules.

 
Do not instantiate - use ring explicit constructors instead:

 
>>> from sympy import QQ
@@ -1069,56 +1069,56 @@ 
Modules, Ideals and their Elementary Properties
 

-contains(elem)[source]

+contains(elem)[source]
 
Return True if elem is an element of this module.

 

 
 

 

-convert(elem, M=None)[source]

+convert(elem, M=None)[source]
 
Convert elem into internal representation of this module.

 
If M is not None, it should be a module containing it.

 

 
 

 

-identity_hom()[source]

+identity_hom()[source]
 
Return the identity homomorphism on self.

 

 
 

 

-is_submodule(other)[source]

+is_submodule(other)[source]
 
Returns True if other is a submodule of self.

 

 
 

 

-is_zero()[source]

+is_zero()[source]
 
Returns True if self is a zero module.

 

 
 

 

-multiply_ideal(other)[source]

+multiply_ideal(other)[source]
 
Multiply self by the ideal other.

 

 
 

 

-quotient_module(other)[source]

+quotient_module(other)[source]
 
Generate a quotient module.

 

 
 

 

-submodule(*gens)[source]

+submodule(*gens)[source]
 
Generate a submodule.

 

 
 

 

-subset(other)[source]

+subset(other)[source]
 
Returns True if other is is a subset of self.

 
Examples

 
>>> from sympy.abc import x
@@ -1136,7 +1136,7 @@ 
Modules, Ideals and their Elementary Properties
 

-class sympy.polys.agca.modules.FreeModule(ring, rank)[source]

+class sympy.polys.agca.modules.FreeModule(ring, rank)[source]
 
Abstract base class for free modules.

 
Additional attributes:

 
    
@@ -1148,7 +1148,7 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-basis()[source]
    
+basis()[source]
 
    Return a set of basis elements.
    
 
    Examples
    
 
    >>> from sympy.abc import x
@@ -1161,7 +1161,7 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-convert(elem, M=None)[source]
    
+convert(elem, M=None)[source]
 
    Convert elem into the internal representation.
    
 
    This method is called implicitly whenever computations involve elements
 not in the internal representation.
    
@@ -1177,13 +1177,13 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-dtype[source]
    
+dtype[source]
 
    alias of FreeModuleElement
    
 

 
 

 

-identity_hom()[source]

+identity_hom()[source]
 
Return the identity homomorphism on self.

 
Examples

 
>>> from sympy.abc import x
@@ -1198,7 +1198,7 @@ 
Modules, Ideals and their Elementary Properties
 

-is_submodule(other)[source]

+is_submodule(other)[source]
 
Returns True if other is a submodule of self.

 
Examples

 
>>> from sympy.abc import x
@@ -1217,7 +1217,7 @@ 
Modules, Ideals and their Elementary Properties
 

-is_zero()[source]

+is_zero()[source]
 
Returns True if self is a zero module.

 
(If, as this implementation assumes, the coefficient ring is not the
 zero ring, then this is equivalent to the rank being zero.)

@@ -1234,7 +1234,7 @@ 
Modules, Ideals and their Elementary Properties
 

-multiply_ideal(other)[source]

+multiply_ideal(other)[source]
 
Multiply self by the ideal other.

 
Examples

 
>>> from sympy.abc import x
@@ -1249,7 +1249,7 @@ 
Modules, Ideals and their Elementary Properties
 

-quotient_module(submodule)[source]

+quotient_module(submodule)[source]
 
Return a quotient module.

 
Examples

 
>>> from sympy.abc import x
@@ -1270,13 +1270,13 @@ 
Modules, Ideals and their Elementary Properties
 

-class sympy.polys.agca.modules.FreeModuleElement(module, data)[source]

+class sympy.polys.agca.modules.FreeModuleElement(module, data)[source]
 
Element of a free module. Data stored as a tuple.

 

 
 

 

-class sympy.polys.agca.modules.SubModule(gens, container)[source]

+class sympy.polys.agca.modules.SubModule(gens, container)[source]
 
Base class for submodules.

 
Attributes:

 
    
@@ -1298,7 +1298,7 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-convert(elem, M=None)[source]
    
+convert(elem, M=None)[source]
 
    Convert elem into the internal represantition.
    
 
    Mostly called implicitly.
    
 
    Examples
    
@@ -1313,7 +1313,7 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-identity_hom()[source]
    
+identity_hom()[source]
 
    Return the identity homomorphism on self.
    
 
    Examples
    
 
    >>> from sympy.abc import x
@@ -1328,7 +1328,7 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-in_terms_of_generators(e)[source]
    
+in_terms_of_generators(e)[source]
 
    Express element e of self in terms of the generators.
    
 
    Examples
    
 
    >>> from sympy.abc import x
@@ -1343,7 +1343,7 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-inclusion_hom()[source]
    
+inclusion_hom()[source]
 
    Return a homomorphism representing the inclusion map of self.
    
 
    That is, the natural map from self to self.container.
    
 
    Examples
    
@@ -1359,7 +1359,7 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-intersect(other, **options)[source]
    
+intersect(other, **options)[source]
 
    Returns the intersection of self with submodule other.
    
 
    Examples
    
 
    >>> from sympy.abc import x, y
@@ -1387,7 +1387,7 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-is_full_module()[source]
    
+is_full_module()[source]
 
    Return True if self is the entire free module.
    
 
    Examples
    
 
    >>> from sympy.abc import x
@@ -1403,7 +1403,7 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-is_submodule(other)[source]
    
+is_submodule(other)[source]
 
    Returns True if other is a submodule of self.
    
 
    >>> from sympy.abc import x
 >>> from sympy import QQ
@@ -1422,7 +1422,7 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-is_zero()[source]
    
+is_zero()[source]
 
    Return True if self is a zero module.
    
 
    Examples
    
 
    >>> from sympy.abc import x
@@ -1438,7 +1438,7 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-module_quotient(other, **options)[source]
    
+module_quotient(other, **options)[source]
 
    Returns the module quotient of self by submodule other.
    
 
    That is, if self is the module \(M\) and other is \(N\), then
 return the ideal \(\{f \in R | fN \subset M\}\).
    
@@ -1470,7 +1470,7 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-multiply_ideal(I)[source]
    
+multiply_ideal(I)[source]
 
    Multiply self by the ideal I.
    
 
    Examples
    
 
    >>> from sympy.abc import x
@@ -1485,7 +1485,7 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-quotient_module(other, **opts)[source]
    
+quotient_module(other, **opts)[source]
 
    Return a quotient module.
    
 
    This is the same as taking a submodule of a quotient of the containing
 module.
    
@@ -1508,7 +1508,7 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-reduce_element(x)[source]
    
+reduce_element(x)[source]
 
    Reduce the element x of our ring modulo the ideal self.
    
 
    Here “reduce” has no specific meaning, it could return a unique normal
 form, simplify the expression a bit, or just do nothing.
    
@@ -1516,7 +1516,7 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-submodule(*gens)[source]
    
+submodule(*gens)[source]
 
    Generate a submodule.
    
 
    Examples
    
 
    >>> from sympy.abc import x
@@ -1530,7 +1530,7 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-syzygy_module(**opts)[source]
    
+syzygy_module(**opts)[source]
 
    Compute the syzygy module of the generators of self.
    
 
    Suppose \(M\) is generated by \(f_1, \ldots, f_n\) over the ring
 \(R\). Consider the homomorphism \(\phi: R^n \to M\), given by
@@ -1556,7 +1556,7 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-union(other)[source]
    
+union(other)[source]
 
    Returns the module generated by the union of self and other.
    
 
    Examples
    
 
    >>> from sympy.abc import x
@@ -1590,7 +1590,7 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-class sympy.polys.agca.ideals.Ideal(ring)[source]
    
+class sympy.polys.agca.ideals.Ideal(ring)[source]
 
    Abstract base class for ideals.
    
 
    Do not instantiate - use explicit constructors in the ring class instead:
    
 
    >>> from sympy import QQ
@@ -1624,7 +1624,7 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-contains(elem)[source]
    
+contains(elem)[source]
 
    Return True if elem is an element of this ideal.
    
 
    Examples
    
 
    >>> from sympy.abc import x
@@ -1639,19 +1639,19 @@ 
    Modules, Ideals and their Elementary Properties
 
    
-depth()[source]
    
+depth()[source]
 
    Compute the depth of self.
    
 

 
 

 

-height()[source]

+height()[source]
 
Compute the height of self.

 

 
 

 

-intersect(J)[source]

+intersect(J)[source]
 
Compute the intersection of self with ideal J.

 
Examples

 
>>> from sympy.abc import x, y
@@ -1665,49 +1665,49 @@ 
Modules, Ideals and their Elementary Properties
 

-is_maximal()[source]

+is_maximal()[source]
 
Return True if self is a maximal ideal.

 

 
 

 

-is_primary()[source]

+is_primary()[source]
 
Return True if self is a primary ideal.

 

 
 

 

-is_prime()[source]

+is_prime()[source]
 
Return True if self is a prime ideal.

 

 
 

 

-is_principal()[source]

+is_principal()[source]
 
Return True if self is a principal ideal.

 

 
 

 

-is_radical()[source]

+is_radical()[source]
 
Return True if self is a radical ideal.

 

 
 

 

-is_whole_ring()[source]

+is_whole_ring()[source]
 
Return True if self is the whole ring.

 

 
 

 

-is_zero()[source]

+is_zero()[source]
 
Return True if self is the zero ideal.

 

 
 

 

-product(J)[source]

+product(J)[source]
 
Compute the ideal product of self and J.

 
That is, compute the ideal generated by products \(xy\), for \(x\) an element
 of self and \(y \in J\).

@@ -1722,7 +1722,7 @@ 
Modules, Ideals and their Elementary Properties
 

-quotient(J, **opts)[source]

+quotient(J, **opts)[source]
 
Compute the ideal quotient of self by J.

 
That is, if self is the ideal \(I\), compute the set
 \(I : J = \{x \in R | xJ \subset I \}\).

@@ -1738,13 +1738,13 @@ 
Modules, Ideals and their Elementary Properties
 

-radical()[source]

+radical()[source]
 
Compute the radical of self.

 

 
 

 

-reduce_element(x)[source]

+reduce_element(x)[source]
 
Reduce the element x of our ring modulo the ideal self.

 
Here “reduce” has no specific meaning: it could return a unique normal
 form, simplify the expression a bit, or just do nothing.

@@ -1752,7 +1752,7 @@ 
Modules, Ideals and their Elementary Properties
 

-saturate(J)[source]

+saturate(J)[source]
 
Compute the ideal saturation of self by J.

 
That is, if self is the ideal \(I\), compute the set
 \(I : J^\infty = \{x \in R | xJ^n \subset I \text{ for some } n\}\).

@@ -1760,7 +1760,7 @@ 
Modules, Ideals and their Elementary Properties
 

-subset(other)[source]

+subset(other)[source]
 
Returns True if other is is a subset of self.

 
Here other may be an ideal.

 
Examples

@@ -1779,7 +1779,7 @@ 
Modules, Ideals and their Elementary Properties
 

-union(J)[source]

+union(J)[source]
 
Compute the ideal generated by the union of self and J.

 
Examples

 
>>> from sympy.abc import x
@@ -1801,7 +1801,7 @@ 
Modules, Ideals and their Elementary Properties
 

-class sympy.polys.agca.modules.QuotientModule(ring, base, submodule)[source]

+class sympy.polys.agca.modules.QuotientModule(ring, base, submodule)[source]
 
Class for quotient modules.

 
Do not instantiate this directly. For subquotients, see the
 SubQuotientModule class.

@@ -1813,7 +1813,7 @@ 
Modules, Ideals and their Elementary Properties
 

-convert(elem, M=None)[source]

+convert(elem, M=None)[source]
 
Convert elem into the internal representation.

 
This method is called implicitly whenever computations involve elements
 not in the internal representation.

@@ -1829,13 +1829,13 @@ 
Modules, Ideals and their Elementary Properties
 

-dtype[source]

+dtype[source]
 
alias of QuotientModuleElement

 

 
 

 

-identity_hom()[source]

+identity_hom()[source]
 
Return the identity homomorphism on self.

 
Examples

 
>>> from sympy.abc import x
@@ -1851,7 +1851,7 @@ 
Modules, Ideals and their Elementary Properties
 

-is_submodule(other)[source]

+is_submodule(other)[source]
 
Return True if other is a submodule of self.

 
Examples

 
>>> from sympy.abc import x
@@ -1868,7 +1868,7 @@ 
Modules, Ideals and their Elementary Properties
 

-is_zero()[source]

+is_zero()[source]
 
Return True if self is a zero module.

 
This happens if and only if the base module is the same as the
 submodule being killed.

@@ -1886,7 +1886,7 @@ 
Modules, Ideals and their Elementary Properties
 

-quotient_hom()[source]

+quotient_hom()[source]
 
Return the quotient homomorphism to self.

 
That is, return a homomorphism representing the natural map from
 self.base to self.

@@ -1904,7 +1904,7 @@ 
Modules, Ideals and their Elementary Properties
 

-submodule(*gens, **opts)[source]

+submodule(*gens, **opts)[source]
 
Generate a submodule.

 
This is the same as taking a quotient of a submodule of the base
 module.

@@ -1922,11 +1922,11 @@ 
Modules, Ideals and their Elementary Properties
 

-class sympy.polys.agca.modules.QuotientModuleElement(module, data)[source]

+class sympy.polys.agca.modules.QuotientModuleElement(module, data)[source]
 
Element of a quotient module.

 

 

-eq(d1, d2)[source]

+eq(d1, d2)[source]
 
Equality comparison.

 

 
@@ -1934,7 +1934,7 @@ 
Modules, Ideals and their Elementary Properties
 

-class sympy.polys.agca.modules.SubQuotientModule(gens, container, **opts)[source]

+class sympy.polys.agca.modules.SubQuotientModule(gens, container, **opts)[source]
 
Submodule of a quotient module.

 
Equivalently, quotient module of a submodule.

 
Do not instantiate this, instead use the submodule or quotient_module
@@ -1955,7 +1955,7 @@ 
Modules, Ideals and their Elementary Properties
 

-is_full_module()[source]

+is_full_module()[source]
 
Return True if self is the entire free module.

 
Examples

 
>>> from sympy.abc import x
@@ -1971,7 +1971,7 @@ 
Modules, Ideals and their Elementary Properties
 

-quotient_hom()[source]

+quotient_hom()[source]
 
Return the quotient homomorphism to self.

 
That is, return the natural map from self.base to self.

 
Examples

@@ -2050,7 +2050,7 @@ 
Module Homomorphisms and Syzygies
 

-sympy.polys.agca.homomorphisms.homomorphism(domain, codomain, matrix)[source]

+sympy.polys.agca.homomorphisms.homomorphism(domain, codomain, matrix)[source]
 
Create a homomorphism object.

 
This function tries to build a homomorphism from domain to codomain
 via the matrix matrix.

@@ -2111,7 +2111,7 @@ 
Module Homomorphisms and Syzygies
 

-class sympy.polys.agca.homomorphisms.ModuleHomomorphism(domain, codomain)[source]

+class sympy.polys.agca.homomorphisms.ModuleHomomorphism(domain, codomain)[source]
 
Abstract base class for module homomoprhisms. Do not instantiate.

 
Instead, use the homomorphism function:

 
>>> from sympy import QQ
@@ -2149,7 +2149,7 @@ 
Module Homomorphisms and Syzygies
 

-image()[source]

+image()[source]
 
Compute the image of self.

 
That is, if self is the homomorphism \(\phi: M \to N\), then compute
 \(im(\phi) = \{\phi(x) | x \in M \}\).  This is a submodule of \(N\).

@@ -2168,7 +2168,7 @@ 
Module Homomorphisms and Syzygies
 

-is_injective()[source]

+is_injective()[source]
 
Return True if self is injective.

 
That is, check if the elements of the domain are mapped to the same
 codomain element.

@@ -2190,7 +2190,7 @@ 
Module Homomorphisms and Syzygies
 

-is_isomorphism()[source]

+is_isomorphism()[source]
 
Return True if self is an isomorphism.

 
That is, check if every element of the codomain has precisely one
 preimage. Equivalently, self is both injective and surjective.

@@ -2213,7 +2213,7 @@ 
Module Homomorphisms and Syzygies
 

-is_surjective()[source]

+is_surjective()[source]
 
Return True if self is surjective.

 
That is, check if every element of the codomain has at least one
 preimage.

@@ -2235,7 +2235,7 @@ 
Module Homomorphisms and Syzygies
 

-is_zero()[source]

+is_zero()[source]
 
Return True if self is a zero morphism.

 
That is, check if every element of the domain is mapped to zero
 under self.

@@ -2259,7 +2259,7 @@ 
Module Homomorphisms and Syzygies
 

-kernel()[source]

+kernel()[source]
 
Compute the kernel of self.

 
That is, if self is the homomorphism \(\phi: M \to N\), then compute
 \(ker(\phi) = \{x \in M | \phi(x) = 0\}\).  This is a submodule of \(M\).

@@ -2278,7 +2278,7 @@ 
Module Homomorphisms and Syzygies
 

-quotient_codomain(sm)[source]

+quotient_codomain(sm)[source]
 
Return self with codomain replaced by codomain/sm.

 
Here sm must be a submodule of self.codomain.

 
Examples

@@ -2310,7 +2310,7 @@ 
Module Homomorphisms and Syzygies
 

-quotient_domain(sm)[source]

+quotient_domain(sm)[source]
 
Return self with domain replaced by domain/sm.

 
Here sm must be a submodule of self.kernel().

 
Examples

@@ -2335,7 +2335,7 @@ 
Module Homomorphisms and Syzygies
 

-restrict_codomain(sm)[source]

+restrict_codomain(sm)[source]
 
Return self, with codomain restricted to to sm.

 
Here sm has to be a submodule of self.codomain containing the
 image.

@@ -2361,7 +2361,7 @@ 
Module Homomorphisms and Syzygies
 

-restrict_domain(sm)[source]

+restrict_domain(sm)[source]
 
Return self, with the domain restricted to sm.

 
Here sm has to be a submodule of self.domain.

 
Examples

@@ -2414,7 +2414,7 @@ 
Finite Extensions\(t\).

 

 

-class sympy.polys.agca.extensions.MonogenicFiniteExtension(mod)[source]

+class sympy.polys.agca.extensions.MonogenicFiniteExtension(mod)[source]
 
Finite extension generated by an integral element.

 
The generator is defined by a monic univariate
 polynomial derived from the argument mod.

@@ -2450,7 +2450,7 @@ 
Finite Extensions
 

-dtype[source]

+dtype[source]
 
alias of ExtensionElement

 

 
@@ -2458,7 +2458,7 @@ 
Finite Extensions
 

-class sympy.polys.agca.extensions.ExtensionElement(rep, ext)[source]

+class sympy.polys.agca.extensions.ExtensionElement(rep, ext)[source]
 
Element of a finite extension.

 
A class of univariate polynomials modulo the modulus
 of the extension ext. It is represented by the
@@ -2467,7 +2467,7 @@ 
Finite Extensions
 

-inverse()[source]

+inverse()[source]
 
Multiplicative inverse.

 

 
Raises:

diff --git a/dev/modules/polys/domainmatrix.html b/dev/modules/polys/domainmatrix.html
index 9b722479a0a..54bd8f8df5c 100644
--- a/dev/modules/polys/domainmatrix.html
+++ b/dev/modules/polys/domainmatrix.html
@@ -833,7 +833,7 @@ 
What is domainmatrix?
 

 

-sympy.polys.matrices.domainmatrix.DM(rows, domain)[source]

+sympy.polys.matrices.domainmatrix.DM(rows, domain)[source]
 
Convenient alias for DomainMatrix.from_list

 
Examples

 
>>> from sympy import ZZ
@@ -850,7 +850,7 @@ 
What is domainmatrix?
 

-class sympy.polys.matrices.domainmatrix.DomainMatrix(rows, shape, domain, *, fmt=None)[source]

+class sympy.polys.matrices.domainmatrix.DomainMatrix(rows, shape, domain, *, fmt=None)[source]
 
Associate Matrix with Domain

 
Explanation

 
DomainMatrix uses Domain for its internal representation
@@ -887,7 +887,7 @@ 
What is domainmatrix?
 

 

-add(B)[source]

+add(B)[source]
 
Adds two DomainMatrix matrices of the same Domain

 

 
Parameters:

@@ -936,7 +936,7 @@ 
What is domainmatrix?
 

-adj_det()[source]

+adj_det()[source]
 
Adjugate and determinant of a square DomainMatrix.

 

 
Returns:

@@ -974,7 +974,7 @@ 
What is domainmatrix?
 

-adj_poly_det(cp=None)[source]

+adj_poly_det(cp=None)[source]
 
Return the polynomial \(p\) such that \(p(A) = adj(A)\) and also the
 determinant of \(A\).

 
Examples

@@ -1003,7 +1003,7 @@ 
What is domainmatrix?
 

-adjugate()[source]

+adjugate()[source]
 
Adjugate of a square DomainMatrix.

 
The adjugate matrix is the transpose of the cofactor matrix and is
 related to the inverse by:

@@ -1036,7 +1036,7 @@ 
What is domainmatrix?
 

-cancel_denom(denom)[source]

+cancel_denom(denom)[source]
 
Cancel factors between a matrix and a denominator.

 
Returns a matrix and denominator on lowest terms.

 
Requires gcd in the ground domain.

@@ -1104,7 +1104,7 @@ 
What is domainmatrix?
 

-cancel_denom_elementwise(denom)[source]

+cancel_denom_elementwise(denom)[source]
 
Cancel factors between the elements of a matrix and a denominator.

 
Returns a matrix of numerators and matrix of denominators.

 
Requires gcd in the ground domain.

@@ -1143,7 +1143,7 @@ 
What is domainmatrix?
 

-charpoly()[source]

+charpoly()[source]
 
Characteristic polynomial of a square matrix.

 
Computes the characteristic polynomial in a fully expanded form using
 division free arithmetic. If a factorization of the characteristic
@@ -1183,7 +1183,7 @@ 
What is domainmatrix?
 

-charpoly_base()[source]

+charpoly_base()[source]
 
Base case for charpoly_factor_blocks() after block decomposition.

 
This method is used internally by charpoly_factor_blocks() as the
 base case for computing the characteristic polynomial of a block. It is
@@ -1201,7 +1201,7 @@ 
What is domainmatrix?
 

-charpoly_berk()[source]

+charpoly_berk()[source]
 
Compute the characteristic polynomial using the Berkowitz algorithm.

 
This method directly calls the underlying implementation of the
 Berkowitz algorithm (sympy.polys.matrices.dense.ddm_berk() or
@@ -1232,7 +1232,7 @@ 
What is domainmatrix?
 

-charpoly_factor_blocks()[source]

+charpoly_factor_blocks()[source]
 
Partial factorisation of the characteristic polynomial.

 
This factorisation arises from a block structure of the matrix (if any)
 and so the factors are not guaranteed to be irreducible. The
@@ -1293,7 +1293,7 @@ 
What is domainmatrix?
 

-charpoly_factor_list()[source]

+charpoly_factor_list()[source]
 
Full factorization of the characteristic polynomial.

 

 
Returns:

@@ -1342,7 +1342,7 @@ 
What is domainmatrix?
 

-choose_domain(**opts)[source]

+choose_domain(**opts)[source]
 
Convert to a domain found by construct_domain().

 
Examples

 
>>> from sympy import ZZ
@@ -1369,7 +1369,7 @@ 
What is domainmatrix?
 

-clear_denoms(convert=False)[source]

+clear_denoms(convert=False)[source]
 
Clear denominators, but keep the domain unchanged.

 
Examples

 
>>> from sympy import QQ
@@ -1409,7 +1409,7 @@ 
What is domainmatrix?
 

-clear_denoms_rowwise(convert=False)[source]

+clear_denoms_rowwise(convert=False)[source]
 
Clear denominators from each row of the matrix.

 
Examples

 
>>> from sympy import QQ
@@ -1455,7 +1455,7 @@ 
What is domainmatrix?
 

-columnspace()[source]

+columnspace()[source]
 
Returns the columnspace for the DomainMatrix

 

 
Returns:

@@ -1479,7 +1479,7 @@ 
What is domainmatrix?
 

-content()[source]

+content()[source]
 
Return the gcd of the elements of the matrix.

 
Requires gcd in the ground domain.

 
Examples

@@ -1498,7 +1498,7 @@ 
What is domainmatrix?
 

-convert_to(K)[source]

+convert_to(K)[source]
 
Change the domain of DomainMatrix to desired domain or field

 

 
Parameters:

@@ -1531,7 +1531,7 @@ 
What is domainmatrix?
 

-det()[source]

+det()[source]
 
Returns the determinant of a square DomainMatrix.

 

 
Returns:

@@ -1563,7 +1563,7 @@ 
What is domainmatrix?
 

-classmethod diag(diagonal, domain, shape=None)[source]

+classmethod diag(diagonal, domain, shape=None)[source]
 
Return diagonal matrix with entries from diagonal.

 
Examples

 
>>> from sympy.polys.matrices import DomainMatrix
@@ -1576,7 +1576,7 @@ 
What is domainmatrix?
 

-diagonal()[source]

+diagonal()[source]
 
Get the diagonal entries of the matrix as a list.

 
Examples

 
>>> from sympy import ZZ
@@ -1594,7 +1594,7 @@ 
What is domainmatrix?
 

-eval_poly(p)[source]

+eval_poly(p)[source]
 
Evaluate polynomial function of a matrix \(p(A)\).

 
Examples

 
>>> from sympy import QQ
@@ -1616,7 +1616,7 @@ 
What is domainmatrix?
 

-eval_poly_mul(p, B)[source]

+eval_poly_mul(p, B)[source]
 
Evaluate polynomial matrix product \(p(A) \times B\).

 
Evaluate the polynomial matrix product \(p(A) \times B\) using Horner’s
 method without creating the matrix \(p(A)\) explicitly. If \(B\) is a
@@ -1648,7 +1648,7 @@ 
What is domainmatrix?
 

-classmethod eye(shape, domain)[source]

+classmethod eye(shape, domain)[source]
 
Return identity matrix of size n or shape (m, n).

 
Examples

 
>>> from sympy.polys.matrices import DomainMatrix
@@ -1669,7 +1669,7 @@ 
What is domainmatrix?**kwargs,

 

 
-)[source]
+)[source]
 
Convert Matrix to DomainMatrix

 

 
Parameters:

@@ -1713,7 +1713,7 @@ 
What is domainmatrix?**kwargs,

 

 
-)[source]
+)[source]
 

 
Parameters:

 
nrows: number of rows

@@ -1741,7 +1741,7 @@ 
What is domainmatrix?
 

-classmethod from_dod(dod, shape, domain)[source]

+classmethod from_dod(dod, shape, domain)[source]
 
Create sparse DomainMatrix from dict of dict (dod) format.

 
See to_dod() for explanation.

 

@@ -1752,7 +1752,7 @@ 
What is domainmatrix?
 

-from_dod_like(dod, domain=None)[source]

+from_dod_like(dod, domain=None)[source]
 
Create DomainMatrix like self from dict of dict (dod) format.

 
See to_dod() for explanation.

 

@@ -1763,7 +1763,7 @@ 
What is domainmatrix?
 

-classmethod from_dok(dok, shape, domain)[source]

+classmethod from_dok(dok, shape, domain)[source]
 
Create DomainMatrix from dictionary of keys (dok) format.

 
See to_dok() for explanation.

 

@@ -1774,7 +1774,7 @@ 
What is domainmatrix?
 

-from_flat_nz(elements, data, domain)[source]

+from_flat_nz(elements, data, domain)[source]
 
Reconstruct DomainMatrix after calling to_flat_nz().

 
See to_flat_nz() for explanation.

 

@@ -1785,7 +1785,7 @@ 
What is domainmatrix?
 

-classmethod from_list(rows, domain)[source]

+classmethod from_list(rows, domain)[source]
 
Convert a list of lists into a DomainMatrix

 

 
Parameters:

@@ -1830,7 +1830,7 @@ 
What is domainmatrix?domain,

 

 
-)[source]
+)[source]
 
Create DomainMatrix from flat list.

 
Examples

 
>>> from sympy import ZZ
@@ -1860,7 +1860,7 @@ 
What is domainmatrix?**kwargs,

 

 
-)[source]
+)[source]
 
Convert a list of lists of Expr into a DomainMatrix using construct_domain

 

 
Parameters:

@@ -1888,7 +1888,7 @@ 
What is domainmatrix?
 

-classmethod from_rep(rep)[source]

+classmethod from_rep(rep)[source]
 
Create a new DomainMatrix efficiently from DDM/SDM.

 

 
Parameters:

@@ -1936,7 +1936,7 @@ 
What is domainmatrix?
 

-hstack(*B)[source]

+hstack(*B)[source]
 
Horizontally stack the given matrices.

 

 
Parameters:

@@ -1976,7 +1976,7 @@ 
What is domainmatrix?
 

-inv()[source]

+inv()[source]
 
Finds the inverse of the DomainMatrix if exists

 

 
Returns:

@@ -2015,7 +2015,7 @@ 
What is domainmatrix?
 

-inv_den(method=None)[source]

+inv_den(method=None)[source]
 
Return the inverse as a DomainMatrix with denominator.

 

 
Parameters:

@@ -2109,7 +2109,7 @@ 
What is domainmatrix?
 

-iter_items()[source]

+iter_items()[source]
 
Iterate over indices and values of nonzero elements of the matrix.

 
Examples

 
>>> from sympy import ZZ
@@ -2127,7 +2127,7 @@ 
What is domainmatrix?
 

-iter_values()[source]

+iter_values()[source]
 
Iterate over nonzero elements of the matrix.

 
Examples

 
>>> from sympy import ZZ
@@ -2145,7 +2145,7 @@ 
What is domainmatrix?
 

-lll(delta=MPQ(3, 4))[source]

+lll(delta=MPQ(3, 4))[source]
 
Performs the Lenstra–Lenstra–Lovász (LLL) basis reduction algorithm.
 See [R780] and [R781].

 

@@ -2210,7 +2210,7 @@ 
What is domainmatrix?
 

-lll_transform(delta=MPQ(3, 4))[source]

+lll_transform(delta=MPQ(3, 4))[source]
 
Performs the Lenstra–Lenstra–Lovász (LLL) basis reduction algorithm
 and returns the reduced basis and transformation matrix.

 
Explanation

@@ -2239,7 +2239,7 @@ 
What is domainmatrix?
 

-lu()[source]

+lu()[source]
 
Returns Lower and Upper decomposition of the DomainMatrix

 

 
Returns:

@@ -2280,7 +2280,7 @@ 
What is domainmatrix?
 

-lu_solve(rhs)[source]

+lu_solve(rhs)[source]
 
Solver for DomainMatrix x in the A*x = B

 

 
Parameters:

@@ -2326,7 +2326,7 @@ 
What is domainmatrix?
 

-matmul(B)[source]

+matmul(B)[source]
 
Performs matrix multiplication of two DomainMatrix matrices

 

 
Parameters:

@@ -2365,7 +2365,7 @@ 
What is domainmatrix?
 

-mul(b)[source]

+mul(b)[source]
 
Performs term by term multiplication for the second DomainMatrix
 w.r.t first DomainMatrix. Returns a DomainMatrix whose rows are
 list of DomainMatrix matrices created after term by term multiplication.

@@ -2404,7 +2404,7 @@ 
What is domainmatrix?
 

-neg()[source]

+neg()[source]
 
Returns the negative of DomainMatrix

 

 
Parameters:

@@ -2433,7 +2433,7 @@ 
What is domainmatrix?
 

-nnz()[source]

+nnz()[source]
 
Number of nonzero elements in the matrix.

 
Examples

 
>>> from sympy import ZZ
@@ -2447,7 +2447,7 @@ 
What is domainmatrix?
 

-nullspace(divide_last=False)[source]

+nullspace(divide_last=False)[source]
 
Returns the nullspace for the DomainMatrix

 

 
Parameters:

@@ -2539,7 +2539,7 @@ 
What is domainmatrix?
 

-nullspace_from_rref(pivots=None)[source]

+nullspace_from_rref(pivots=None)[source]
 
Compute nullspace from rref and pivots.

 
The domain of the matrix can be any domain.

 
The matrix must be in reduced row echelon form already. Otherwise the
@@ -2553,7 +2553,7 @@ 
What is domainmatrix?
 

-classmethod ones(shape, domain)[source]

+classmethod ones(shape, domain)[source]
 
Returns a DomainMatrix of 1s, of size shape, belonging to the specified domain

 
Examples

 
>>> from sympy.polys.matrices import DomainMatrix
@@ -2566,7 +2566,7 @@ 
What is domainmatrix?
 

-pow(n)[source]

+pow(n)[source]
 
Computes A**n

 

 
Parameters:

@@ -2606,7 +2606,7 @@ 
What is domainmatrix?
 

-primitive()[source]

+primitive()[source]
 
Factor out gcd of the elements of a matrix.

 
Requires gcd in the ground domain.

 
Examples

@@ -2632,7 +2632,7 @@ 
What is domainmatrix?
 

-rowspace()[source]

+rowspace()[source]
 
Returns the rowspace for the DomainMatrix

 

 
Returns:

@@ -2656,7 +2656,7 @@ 
What is domainmatrix?
 

-rref(*, method='auto')[source]

+rref(*, method='auto')[source]
 
Returns reduced-row echelon form (RREF) and list of pivots.

 
If the domain is not a field then it will be converted to a field. See
 rref_den() for the fraction-free version of this routine that
@@ -2751,7 +2751,7 @@ 
What is domainmatrix?keep_domain=True,

 

 
-)[source]
+)[source]
 
Returns reduced-row echelon form with denominator and list of pivots.

 
Requires exact division in the ground domain (exquo).

 

@@ -2856,7 +2856,7 @@ 
What is domainmatrix?
 

-scc()[source]

+scc()[source]
 
Compute the strongly connected components of a DomainMatrix

 

 
Returns:

@@ -2924,7 +2924,7 @@ 
What is domainmatrix?
 

-solve_den(b, method=None)[source]

+solve_den(b, method=None)[source]
 
Solve matrix equation \(Ax = b\) without fractions in the ground domain.

 

 
Parameters:

@@ -3058,7 +3058,7 @@ 
What is domainmatrix?check=True,

 

 
-)[source]
+)[source]
 
Solve matrix equation \(Ax = b\) using the characteristic polynomial.

 
This method solves the square matrix equation \(Ax = b\) for \(x\) using
 the characteristic polynomial without any division or fractions in the
@@ -3129,7 +3129,7 @@ 
What is domainmatrix?
 

-solve_den_rref(b)[source]

+solve_den_rref(b)[source]
 
Solve matrix equation \(Ax = b\) using fraction-free RREF

 
Solves the matrix equation \(Ax = b\) for \(x\) and returns the solution
 as a numerator/denominator pair.

@@ -3155,7 +3155,7 @@ 
What is domainmatrix?
 

-sub(B)[source]

+sub(B)[source]
 
Subtracts two DomainMatrix matrices of the same Domain

 

 
Parameters:

@@ -3204,7 +3204,7 @@ 
What is domainmatrix?
 

-to_Matrix()[source]

+to_Matrix()[source]
 
Convert DomainMatrix to Matrix

 

 
Returns:

@@ -3236,7 +3236,7 @@ 
What is domainmatrix?
 

-to_ddm()[source]

+to_ddm()[source]
 
Return a DDM representation of self.

 
Examples

 
>>> from sympy.polys.matrices import DomainMatrix
@@ -3257,7 +3257,7 @@ 
What is domainmatrix?
 

-to_dense()[source]

+to_dense()[source]
 
Return a dense DomainMatrix representation of self.

 
Examples

 
>>> from sympy.polys.matrices import DomainMatrix
@@ -3274,7 +3274,7 @@ 
What is domainmatrix?
 

-to_dfm()[source]

+to_dfm()[source]
 
Return a DFM representation of self.

 
Examples

 
>>> from sympy.polys.matrices import DomainMatrix
@@ -3295,7 +3295,7 @@ 
What is domainmatrix?
 

-to_dfm_or_ddm()[source]

+to_dfm_or_ddm()[source]
 
Return a DFM or DDM representation of self.

 
Explanation

 
The DFM representation can only be used if the ground types
@@ -3332,7 +3332,7 @@ 
What is domainmatrix?
 

-to_dod()[source]

+to_dod()[source]
 
Convert DomainMatrix to dictionary of dictionaries (dod) format.

 
Explanation

 
Returns a dictionary of dictionaries representing the matrix.

@@ -3356,7 +3356,7 @@ 
What is domainmatrix?
 

-to_dok()[source]

+to_dok()[source]
 
Convert DomainMatrix to dictionary of keys (dok) format.

 
Examples

 
>>> from sympy import ZZ
@@ -3382,7 +3382,7 @@ 
What is domainmatrix?
 

-to_field()[source]

+to_field()[source]
 
Returns a DomainMatrix with the appropriate field

 

 
Returns:

@@ -3408,7 +3408,7 @@ 
What is domainmatrix?
 

-to_flat_nz()[source]

+to_flat_nz()[source]
 
Convert DomainMatrix to list of nonzero elements and data.

 
Explanation

 
Returns a tuple (elements, data) where elements is a list of
@@ -3451,7 +3451,7 @@ 
What is domainmatrix?
 

-to_list()[source]

+to_list()[source]
 
Convert DomainMatrix to list of lists.

 

 
See also

@@ -3461,7 +3461,7 @@ 
What is domainmatrix?
 

-to_list_flat()[source]

+to_list_flat()[source]
 
Convert DomainMatrix to flat list.

 
Examples

 
>>> from sympy import ZZ
@@ -3479,7 +3479,7 @@ 
What is domainmatrix?
 

-to_sdm()[source]

+to_sdm()[source]
 
Return a SDM representation of self.

 
Examples

 
>>> from sympy.polys.matrices import DomainMatrix
@@ -3500,7 +3500,7 @@ 
What is domainmatrix?
 

-to_sparse()[source]

+to_sparse()[source]
 
Return a sparse DomainMatrix representation of self.

 
Examples

 
>>> from sympy.polys.matrices import DomainMatrix
@@ -3517,13 +3517,13 @@ 
What is domainmatrix?
 

-transpose()[source]

+transpose()[source]
 
Matrix transpose of self

 

 
 

 

-unify(*others, fmt=None)[source]

+unify(*others, fmt=None)[source]
 
Unifies the domains and the format of self and other
 matrices.

 

@@ -3576,7 +3576,7 @@ 
What is domainmatrix?
 

-vstack(*B)[source]

+vstack(*B)[source]
 
Vertically stack the given matrices.

 

 
Parameters:

@@ -3616,7 +3616,7 @@ 
What is domainmatrix?
 

-classmethod zeros(shape, domain, *, fmt='sparse')[source]

+classmethod zeros(shape, domain, *, fmt='sparse')[source]
 
Returns a zero DomainMatrix of size shape, belonging to the specified domain

 
Examples

 
>>> from sympy.polys.matrices import DomainMatrix
@@ -3686,31 +3686,31 @@ 
What is domainmatrix?
 

 

-class sympy.polys.matrices.ddm.DDM(rowslist, shape, domain)[source]

+class sympy.polys.matrices.ddm.DDM(rowslist, shape, domain)[source]
 
Dense matrix based on polys domain elements

 
This is a list subclass and is a wrapper for a list of lists that supports
 basic matrix arithmetic +, -, , *.

 

 

-add(b)[source]

+add(b)[source]
 
a + b

 

 
 

 

-charpoly()[source]

+charpoly()[source]
 
Coefficients of characteristic polynomial of a

 

 
 

 

-det()[source]

+det()[source]
 
Determinant of a

 

 
 

 

-classmethod diag(values, domain)[source]

+classmethod diag(values, domain)[source]
 
Returns a square diagonal matrix with values on the diagonal.

 
Examples

 
>>> from sympy import ZZ
@@ -3727,13 +3727,13 @@ 
What is domainmatrix?
 

-diagonal()[source]

+diagonal()[source]
 
Returns a list of the elements from the diagonal of the matrix.

 

 
 

 

-classmethod from_dod(dod, shape, domain)[source]

+classmethod from_dod(dod, shape, domain)[source]
 
Create a DDM from a dictionary of dictionaries (dod) format.

 
Examples

 
>>> from sympy.polys.matrices.ddm import DDM
@@ -3752,7 +3752,7 @@ 
What is domainmatrix?
 

-classmethod from_dok(dok, shape, domain)[source]

+classmethod from_dok(dok, shape, domain)[source]
 
Create a DDM from a dictionary of keys (dok) format.

 
Examples

 
>>> from sympy.polys.matrices.ddm import DDM
@@ -3771,7 +3771,7 @@ 
What is domainmatrix?
 

-classmethod from_flat_nz(elements, data, domain)[source]

+classmethod from_flat_nz(elements, data, domain)[source]
 
Reconstruct a DDM after calling to_flat_nz().

 
Examples

 
>>> from sympy.polys.matrices.ddm import DDM
@@ -3792,7 +3792,7 @@ 
What is domainmatrix?
 

-classmethod from_list(rowslist, shape, domain)[source]

+classmethod from_list(rowslist, shape, domain)[source]
 
Create a DDM from a list of lists.

 
Examples

 
>>> from sympy import ZZ
@@ -3812,7 +3812,7 @@ 
What is domainmatrix?
 

-classmethod from_list_flat(flat, shape, domain)[source]

+classmethod from_list_flat(flat, shape, domain)[source]
 
Create a DDM from a flat list of elements.

 
Examples

 
>>> from sympy import QQ
@@ -3832,7 +3832,7 @@ 
What is domainmatrix?
 

-hstack(*B)[source]

+hstack(*B)[source]
 
Horizontally stacks DDM matrices.

 
Examples

 
>>> from sympy import ZZ
@@ -3854,40 +3854,40 @@ 
What is domainmatrix?
 

-inv()[source]

+inv()[source]
 
Inverse of a

 

 
 

 

-is_diagonal()[source]

+is_diagonal()[source]
 
Says whether this matrix is diagonal. True can be returned even if
 the matrix is not square.

 

 
 

 

-is_lower()[source]

+is_lower()[source]
 
Says whether this matrix is lower-triangular. True can be returned
 even if the matrix is not square.

 

 
 

 

-is_upper()[source]

+is_upper()[source]
 
Says whether this matrix is upper-triangular. True can be returned
 even if the matrix is not square.

 

 
 

 

-is_zero_matrix()[source]

+is_zero_matrix()[source]
 
Says whether this matrix has all zero entries.

 

 
 

 

-iter_items()[source]

+iter_items()[source]
 
Iterate over indices and values of nonzero elements of the matrix.

 
Examples

 
>>> from sympy.polys.matrices.ddm import DDM
@@ -3905,7 +3905,7 @@ 
What is domainmatrix?
 

-iter_values()[source]

+iter_values()[source]
 
Iterater over the non-zero values of the matrix.

 
Examples

 
>>> from sympy.polys.matrices.ddm import DDM
@@ -3923,31 +3923,31 @@ 
What is domainmatrix?
 

-lu()[source]

+lu()[source]
 
L, U decomposition of a

 

 
 

 

-lu_solve(b)[source]

+lu_solve(b)[source]
 
x where a*x = b

 

 
 

 

-matmul(b)[source]

+matmul(b)[source]
 
a @ b (matrix product)

 

 
 

 

-neg()[source]

+neg()[source]
 
-a

 

 
 

 

-nnz()[source]

+nnz()[source]
 
Number of non-zero entries in DDM matrix.

 

 
See also

@@ -3957,7 +3957,7 @@ 
What is domainmatrix?
 

-nullspace()[source]

+nullspace()[source]
 
Returns a basis for the nullspace of a.

 
The domain of the matrix must be a field.

 

@@ -3968,7 +3968,7 @@ 
What is domainmatrix?
 

-nullspace_from_rref(pivots=None)[source]

+nullspace_from_rref(pivots=None)[source]
 
Compute the nullspace of a matrix from its rref.

 
The domain of the matrix can be any domain.

 
Returns a tuple (basis, nonpivots).

@@ -3983,7 +3983,7 @@ 
What is domainmatrix?
 

-rref()[source]

+rref()[source]
 
Reduced-row echelon form of a and list of pivots.

 

 
See also

@@ -3998,7 +3998,7 @@ 
What is domainmatrix?
 

-rref_den()[source]

+rref_den()[source]
 
Reduced-row echelon form of a with denominator and list of pivots

 

 
See also

@@ -4013,7 +4013,7 @@ 
What is domainmatrix?
 

-scc()[source]

+scc()[source]
 
Strongly connected components of a square matrix a.

 
Examples

 
>>> from sympy import ZZ
@@ -4031,13 +4031,13 @@ 
What is domainmatrix?
 

-sub(b)[source]

+sub(b)[source]
 
a - b

 

 
 

 

-to_ddm()[source]

+to_ddm()[source]
 
Convert to a DDM.

 
This just returns self but exists to parallel the corresponding
 method in other matrix types like SDM.

@@ -4049,7 +4049,7 @@ 
What is domainmatrix?
 

-to_dfm()[source]

+to_dfm()[source]
 
Convert to DDM to DFM.

 
Examples

 
>>> from sympy.polys.matrices.ddm import DDM
@@ -4069,7 +4069,7 @@ 
What is domainmatrix?
 

-to_dfm_or_ddm()[source]

+to_dfm_or_ddm()[source]
 
Convert to DFM if possible or otherwise return self.

 
Examples

 
>>> from sympy.polys.matrices.ddm import DDM
@@ -4089,7 +4089,7 @@ 
What is domainmatrix?
 

-to_dod()[source]

+to_dod()[source]
 
Convert to a dictionary of dictionaries (dod) format.

 
Examples

 
>>> from sympy.polys.matrices.ddm import DDM
@@ -4107,7 +4107,7 @@ 
What is domainmatrix?
 

-to_dok()[source]

+to_dok()[source]
 
Convert DDM to dictionary of keys (dok) format.

 
Examples

 
>>> from sympy.polys.matrices.ddm import DDM
@@ -4125,7 +4125,7 @@ 
What is domainmatrix?
 

-to_flat_nz()[source]

+to_flat_nz()[source]
 
Convert to a flat list of nonzero elements and data.

 
Explanation

 
This is used to operate on a list of the elements of a matrix and then
@@ -4150,7 +4150,7 @@ 
What is domainmatrix?
 

-to_list()[source]

+to_list()[source]
 
Convert to a list of lists.

 
Examples

 
>>> from sympy import QQ
@@ -4168,7 +4168,7 @@ 
What is domainmatrix?
 

-to_list_flat()[source]

+to_list_flat()[source]
 
Convert to a flat list of elements.

 
Examples

 
>>> from sympy import QQ
@@ -4188,7 +4188,7 @@ 
What is domainmatrix?
 

-to_sdm()[source]

+to_sdm()[source]
 
Convert to a SDM.

 
Examples

 
>>> from sympy.polys.matrices.ddm import DDM
@@ -4208,7 +4208,7 @@ 
What is domainmatrix?
 

-vstack(*B)[source]

+vstack(*B)[source]
 
Vertically stacks DDM matrices.

 
Examples

 
>>> from sympy import ZZ
@@ -4277,7 +4277,7 @@ 
What is domainmatrix?
 

-sympy.polys.matrices.dense.ddm_berk(M, K)[source]

+sympy.polys.matrices.dense.ddm_berk(M, K)[source]
 
Berkowitz algorithm for computing the characteristic polynomial.

 
Explanation

 
The Berkowitz algorithm is a division-free algorithm for computing the
@@ -4319,13 +4319,13 @@ 
What is domainmatrix?b: Sequence[Sequence[R]],

 

 
-) → None[source]
+) → None[source]
 
a += b

 

 
 

 

-sympy.polys.matrices.dense.ddm_idet(a, K)[source]

+sympy.polys.matrices.dense.ddm_idet(a, K)[source]
 
a  <–  echelon(a); return det

 
Explanation

 
Compute the determinant of \(a\) using the Bareiss fraction-free algorithm.
@@ -4368,7 +4368,7 @@ 
What is domainmatrix?
 

-sympy.polys.matrices.dense.ddm_iinv(ainv, a, K)[source]

+sympy.polys.matrices.dense.ddm_iinv(ainv, a, K)[source]
 
ainv  <–  inv(a)

 
Compute the inverse of a matrix \(a\) over a field \(K\) using Gauss-Jordan
 elimination. The result is stored in \(ainv\).

@@ -4398,7 +4398,7 @@ 
What is domainmatrix?
 

-sympy.polys.matrices.dense.ddm_ilu(a)[source]

+sympy.polys.matrices.dense.ddm_ilu(a)[source]
 
a  <–  LU(a)

 
Computes the LU decomposition of a matrix in place. Returns a list of
 row swaps that were performed.

@@ -4443,7 +4443,7 @@ 
What is domainmatrix?
 

-sympy.polys.matrices.dense.ddm_ilu_solve(x, L, U, swaps, b)[source]

+sympy.polys.matrices.dense.ddm_ilu_solve(x, L, U, swaps, b)[source]
 
x  <–  solve(L*U*x = swaps(b))

 
Solve a linear system, \(A*x = b\), given an LU factorization of \(A\).

 
Uses division in the ground domain which must be a field.

@@ -4482,7 +4482,7 @@ 
What is domainmatrix?
 

-sympy.polys.matrices.dense.ddm_ilu_split(L, U, K)[source]

+sympy.polys.matrices.dense.ddm_ilu_split(L, U, K)[source]
 
L, U  <–  LU(U)

 
Compute the LU decomposition of a matrix \(L\) in place and store the lower
 and upper triangular matrices in \(L\) and \(U\), respectively. Returns a list
@@ -4518,7 +4518,7 @@ 
What is domainmatrix?c: Sequence[Sequence[R]],

 

 
-) → None[source]
+) → None[source]
 
a += b @ c

 

 
@@ -4531,7 +4531,7 @@ 
What is domainmatrix?b: R,

 

 
-) → None[source]
+) → None[source]
 
a <– a*b

 

 
@@ -4543,7 +4543,7 @@ 
What is domainmatrix?a: list[list[R]],

 

 
-) → None[source]
+) → None[source]
 
a <– -a

 

 
@@ -4556,13 +4556,13 @@ 
What is domainmatrix?b: R,

 

 
-) → None[source]
+) → None[source]
 
a <– b*a

 

 
 

 

-sympy.polys.matrices.dense.ddm_irref(a, _partial_pivot=False)[source]

+sympy.polys.matrices.dense.ddm_irref(a, _partial_pivot=False)[source]
 
In-place reduced row echelon form of a matrix.

 
Compute the reduced row echelon form of \(a\). Modifies \(a\) in place and
 returns a list of the pivot columns.

@@ -4611,7 +4611,7 @@ 
What is domainmatrix?
 

-sympy.polys.matrices.dense.ddm_irref_den(a, K)[source]

+sympy.polys.matrices.dense.ddm_irref_den(a, K)[source]
 
a  <–  rref(a); return (den, pivots)

 
Compute the fraction-free reduced row echelon form (RREF) of \(a\). Modifies
 \(a\) in place and returns a tuple containing the denominator of the RREF and
@@ -4677,7 +4677,7 @@ 
What is domainmatrix?b: Sequence[Sequence[R]],

 

 
-) → None[source]
+) → None[source]
 
a -= b

 

 
@@ -4689,13 +4689,13 @@ 
What is domainmatrix?matrix: Sequence[Sequence[T]],

 

 
-) → list[list[T]][source]
+) → list[list[T]][source]
 
matrix transpose

 

 
 

 

-class sympy.polys.matrices._typing.RingElement(*args, **kwargs)[source]

+class sympy.polys.matrices._typing.RingElement(*args, **kwargs)[source]
 
A ring element.

 
Must support +, -, *, ** and -.

 

@@ -4703,7 +4703,7 @@ 
What is domainmatrix?Module for the SDM class.

 

 

-class sympy.polys.matrices.sdm.SDM(elemsdict, shape, domain)[source]

+class sympy.polys.matrices.sdm.SDM(elemsdict, shape, domain)[source]
 
Sparse matrix based on polys domain elements

 
This is a dict subclass and is a wrapper for a dict of dicts that supports
 basic matrix arithmetic +, -, , *.

@@ -4747,7 +4747,7 @@ 
What is domainmatrix?
 

 

-add(B)[source]

+add(B)[source]
 
Adds two SDM matrices

 
Examples

 
>>> from sympy import ZZ
@@ -4762,7 +4762,7 @@ 
What is domainmatrix?
 

-charpoly()[source]

+charpoly()[source]
 
Returns the coefficients of the characteristic polynomial
 of the SDM matrix. These elements will be domain elements.
 The domain of the elements will be same as domain of the SDM.

@@ -4787,7 +4787,7 @@ 
What is domainmatrix?
 

-convert_to(K)[source]

+convert_to(K)[source]
 
Converts the Domain of a SDM matrix to K

 
Examples

 
>>> from sympy import ZZ, QQ
@@ -4801,7 +4801,7 @@ 
What is domainmatrix?
 

-copy()[source]

+copy()[source]
 
Returns the copy of a SDM object

 
Examples

 
>>> from sympy.polys.matrices.sdm import SDM
@@ -4817,7 +4817,7 @@ 
What is domainmatrix?
 

-det()[source]

+det()[source]
 
Returns determinant of A

 
Examples

 
>>> from sympy import QQ
@@ -4831,13 +4831,13 @@ 
What is domainmatrix?
 

-diagonal()[source]

+diagonal()[source]
 
Returns the diagonal of the matrix as a list.

 

 
 

 

-classmethod eye(shape, domain)[source]

+classmethod eye(shape, domain)[source]
 
Returns a identity SDM matrix of dimensions
 size x size, belonging to the specified domain

 
Examples

@@ -4852,7 +4852,7 @@ 
What is domainmatrix?
 

-classmethod from_ddm(ddm)[source]

+classmethod from_ddm(ddm)[source]
 
Create SDM from a DDM.

 
Examples

 
>>> from sympy.polys.matrices.ddm import DDM
@@ -4874,7 +4874,7 @@ 
What is domainmatrix?
 

-classmethod from_dod(dod, shape, domain)[source]

+classmethod from_dod(dod, shape, domain)[source]
 
Create SDM from dictionary of dictionaries (dod) format.

 
Examples

 
>>> from sympy.polys.matrices.sdm import SDM
@@ -4895,7 +4895,7 @@ 
What is domainmatrix?
 

-classmethod from_dok(dok, shape, domain)[source]

+classmethod from_dok(dok, shape, domain)[source]
 
Create SDM from dictionary of keys (dok) format.

 
Examples

 
>>> from sympy.polys.matrices.sdm import SDM
@@ -4916,7 +4916,7 @@ 
What is domainmatrix?
 

-classmethod from_flat_nz(elements, data, domain)[source]

+classmethod from_flat_nz(elements, data, domain)[source]
 
Reconstruct a SDM after calling to_flat_nz().

 
See to_flat_nz() for explanation.

 

@@ -4927,7 +4927,7 @@ 
What is domainmatrix?
 

-classmethod from_list(ddm, shape, domain)[source]

+classmethod from_list(ddm, shape, domain)[source]
 
Create SDM object from a list of lists.

 

 
Parameters:

@@ -4965,7 +4965,7 @@ 
What is domainmatrix?
 

-classmethod from_list_flat(elements, shape, domain)[source]

+classmethod from_list_flat(elements, shape, domain)[source]
 
Create SDM from a flat list of elements.

 
Examples

 
>>> from sympy.polys.matrices.sdm import SDM
@@ -4985,7 +4985,7 @@ 
What is domainmatrix?
 

-hstack(*B)[source]

+hstack(*B)[source]
 
Horizontally stacks SDM matrices.

 
Examples

 
>>> from sympy import ZZ
@@ -5007,7 +5007,7 @@ 
What is domainmatrix?
 

-inv()[source]

+inv()[source]
 
Returns inverse of a matrix A

 
Examples

 
>>> from sympy import QQ
@@ -5021,34 +5021,34 @@ 
What is domainmatrix?
 

-is_diagonal()[source]

+is_diagonal()[source]
 
Says whether this matrix is diagonal. True can be returned
 even if the matrix is not square.

 

 
 

 

-is_lower()[source]

+is_lower()[source]
 
Says whether this matrix is lower-triangular. True can be returned
 even if the matrix is not square.

 

 
 

 

-is_upper()[source]

+is_upper()[source]
 
Says whether this matrix is upper-triangular. True can be returned
 even if the matrix is not square.

 

 
 

 

-is_zero_matrix()[source]

+is_zero_matrix()[source]
 
Says whether this matrix has all zero entries.

 

 
 

 

-iter_items()[source]

+iter_items()[source]
 
Iterate over indices and values of the nonzero elements.

 
Examples

 
>>> from sympy.polys.matrices.sdm import SDM
@@ -5066,7 +5066,7 @@ 
What is domainmatrix?
 

-iter_values()[source]

+iter_values()[source]
 
Iterate over the nonzero values of a SDM matrix.

 
Examples

 
>>> from sympy.polys.matrices.sdm import SDM
@@ -5080,19 +5080,19 @@ 
What is domainmatrix?
 

-lll(delta=MPQ(3, 4))[source]

+lll(delta=MPQ(3, 4))[source]
 
Returns the LLL-reduced basis for the SDM matrix.

 

 
 

 

-lll_transform(delta=MPQ(3, 4))[source]

+lll_transform(delta=MPQ(3, 4))[source]
 
Returns the LLL-reduced basis and transformation matrix.

 

 
 

 

-lu()[source]

+lu()[source]
 
Returns LU decomposition for a matrix A

 
Examples

 
>>> from sympy import QQ
@@ -5106,7 +5106,7 @@ 
What is domainmatrix?
 

-lu_solve(b)[source]

+lu_solve(b)[source]
 
Uses LU decomposition to solve Ax = b,

 
Examples

 
>>> from sympy import QQ
@@ -5121,7 +5121,7 @@ 
What is domainmatrix?
 

-matmul(B)[source]

+matmul(B)[source]
 
Performs matrix multiplication of two SDM matrices

 

 
Parameters:

@@ -5154,7 +5154,7 @@ 
What is domainmatrix?
 

-mul(b)[source]

+mul(b)[source]
 
Multiplies each element of A with a scalar b

 
Examples

 
>>> from sympy import ZZ
@@ -5168,7 +5168,7 @@ 
What is domainmatrix?
 

-neg()[source]

+neg()[source]
 
Returns the negative of a SDM matrix

 
Examples

 
>>> from sympy import ZZ
@@ -5182,7 +5182,7 @@ 
What is domainmatrix?
 

-classmethod new(sdm, shape, domain)[source]

+classmethod new(sdm, shape, domain)[source]
 

 
Parameters:

 
sdm: A dict of dicts for non-zero elements in SDM

@@ -5206,7 +5206,7 @@ 
What is domainmatrix?
 

-nnz()[source]

+nnz()[source]
 
Number of non-zero elements in the SDM matrix.

 
Examples

 
>>> from sympy import ZZ
@@ -5224,7 +5224,7 @@ 
What is domainmatrix?
 

-nullspace()[source]

+nullspace()[source]
 
Nullspace of a SDM matrix A.

 
The domain of the matrix must be a field.

 
It is better to use the nullspace() method rather
@@ -5248,7 +5248,7 @@ 
What is domainmatrix?
 

-nullspace_from_rref(pivots=None)[source]

+nullspace_from_rref(pivots=None)[source]
 
Returns nullspace for a SDM matrix A in RREF.

 
The domain of the matrix can be any domain.

 
The matrix must already be in reduced row echelon form (RREF).

@@ -5281,7 +5281,7 @@ 
What is domainmatrix?
 

-rref()[source]

+rref()[source]
 
Returns reduced-row echelon form and list of pivots for the SDM

 
Examples

 
>>> from sympy import QQ
@@ -5295,7 +5295,7 @@ 
What is domainmatrix?
 

-rref_den()[source]

+rref_den()[source]
 
Returns reduced-row echelon form (RREF) with denominator and pivots.

 
Examples

 
>>> from sympy import QQ
@@ -5309,7 +5309,7 @@ 
What is domainmatrix?
 

-scc()[source]

+scc()[source]
 
Strongly connected components of a square matrix A.

 
Examples

 
>>> from sympy import ZZ
@@ -5327,7 +5327,7 @@ 
What is domainmatrix?
 

-sub(B)[source]

+sub(B)[source]
 
Subtracts two SDM matrices

 
Examples

 
>>> from sympy import ZZ
@@ -5342,7 +5342,7 @@ 
What is domainmatrix?
 

-to_ddm()[source]

+to_ddm()[source]
 
Convert a SDM object to a DDM object

 
Examples

 
>>> from sympy.polys.matrices.sdm import SDM
@@ -5356,7 +5356,7 @@ 
What is domainmatrix?
 

-to_dfm()[source]

+to_dfm()[source]
 
Convert a SDM object to a DFM object

 
Examples

 
>>> from sympy.polys.matrices.sdm import SDM
@@ -5374,7 +5374,7 @@ 
What is domainmatrix?
 

-to_dfm_or_ddm()[source]

+to_dfm_or_ddm()[source]
 
Convert to DFM if possible, else DDM.

 
Examples

 
>>> from sympy.polys.matrices.sdm import SDM
@@ -5394,7 +5394,7 @@ 
What is domainmatrix?
 

-to_dod()[source]

+to_dod()[source]
 
Convert to dictionary of dictionaries (dod) format.

 
Examples

 
>>> from sympy.polys.matrices.sdm import SDM
@@ -5412,7 +5412,7 @@ 
What is domainmatrix?
 

-to_dok()[source]

+to_dok()[source]
 
Convert to dictionary of keys (dok) format.

 
Examples

 
>>> from sympy.polys.matrices.sdm import SDM
@@ -5430,7 +5430,7 @@ 
What is domainmatrix?
 

-to_flat_nz()[source]

+to_flat_nz()[source]
 
Convert SDM to a flat list of nonzero elements and data.

 
Explanation

 
This is used to operate on a list of the elements of a matrix and then
@@ -5455,7 +5455,7 @@ 
What is domainmatrix?
 

-to_list()[source]

+to_list()[source]
 
Convert a SDM object to a list of lists.

 
Examples

 
>>> from sympy.polys.matrices.sdm import SDM
@@ -5470,7 +5470,7 @@ 
What is domainmatrix?
 

-to_list_flat()[source]

+to_list_flat()[source]
 
Convert SDM to a flat list.

 
Examples

 
>>> from sympy.polys.matrices.sdm import SDM
@@ -5490,13 +5490,13 @@ 
What is domainmatrix?
 

-to_sdm()[source]

+to_sdm()[source]
 
Convert to SDM format (returns self).

 

 
 

 

-transpose()[source]

+transpose()[source]
 
Returns the transpose of a SDM matrix

 
Examples

 
>>> from sympy.polys.matrices.sdm import SDM
@@ -5510,7 +5510,7 @@ 
What is domainmatrix?
 

-vstack(*B)[source]

+vstack(*B)[source]
 
Vertically stacks SDM matrices.

 
Examples

 
>>> from sympy import ZZ
@@ -5532,7 +5532,7 @@ 
What is domainmatrix?
 

-classmethod zeros(shape, domain)[source]

+classmethod zeros(shape, domain)[source]
 
Returns a SDM of size shape,
 belonging to the specified domain

 
In the example below we declare a matrix A where,

@@ -5555,7 +5555,7 @@ 
What is domainmatrix?
 

-sympy.polys.matrices.sdm.sdm_berk(M, n, K)[source]

+sympy.polys.matrices.sdm.sdm_berk(M, n, K)[source]
 
Berkowitz algorithm for computing the characteristic polynomial.

 
Explanation

 
The Berkowitz algorithm is a division-free algorithm for computing the
@@ -5593,7 +5593,7 @@ 
What is domainmatrix?
 

-sympy.polys.matrices.sdm.sdm_irref(A)[source]

+sympy.polys.matrices.sdm.sdm_irref(A)[source]
 
RREF and pivots of a sparse matrix A.

 
Compute the reduced row echelon form (RREF) of the matrix A and return a
 list of the pivot columns. This routine does not work in place and leaves
@@ -5660,19 +5660,19 @@ 
What is domainmatrix?nonzero_cols,

 

 
-)[source]
+)[source]
 
Get nullspace from A which is in RREF

 

 
 

 

-sympy.polys.matrices.sdm.sdm_particular_from_rref(A, ncols, pivots)[source]

+sympy.polys.matrices.sdm.sdm_particular_from_rref(A, ncols, pivots)[source]
 
Get a particular solution from A which is in RREF

 

 
 

 

-sympy.polys.matrices.sdm.sdm_rref_den(A, K)[source]

+sympy.polys.matrices.sdm.sdm_rref_den(A, K)[source]
 
Return the reduced row echelon form (RREF) of A with denominator.

 
The RREF is computed using fraction-free Gauss-Jordan elimination.

 
Explanation

@@ -5726,7 +5726,7 @@ 
What is domainmatrix?
 

-class sympy.polys.matrices._dfm.DFM(rowslist, shape, domain)[source]

+class sympy.polys.matrices._dfm.DFM(rowslist, shape, domain)[source]
 
Dense FLINT matrix. This class is a wrapper for matrices from python-flint.

 
>>> from sympy.polys.domains import ZZ
 >>> from sympy.polys.matrices.dfm import DFM
@@ -5760,19 +5760,19 @@ 
What is domainmatrix?
 

 

-add(other)[source]

+add(other)[source]
 
Add two DFM matrices.

 

 
 

 

-applyfunc(func, domain)[source]

+applyfunc(func, domain)[source]
 
Apply a function to each entry of a DFM matrix.

 

 
 

 

-charpoly()[source]

+charpoly()[source]
 
Compute the characteristic polynomial of the matrix using FLINT.

 
Examples

 
>>> from sympy import Matrix
@@ -5807,19 +5807,19 @@ 
What is domainmatrix?
 

-convert_to(domain)[source]

+convert_to(domain)[source]
 
Convert to a new domain.

 

 
 

 

-copy()[source]

+copy()[source]
 
Return a copy of self.

 

 
 

 

-det()[source]

+det()[source]
 
Compute the determinant of the matrix using FLINT.

 
Examples

 
>>> from sympy import Matrix
@@ -5860,85 +5860,85 @@ 
What is domainmatrix?
 

-classmethod diag(elements, domain)[source]

+classmethod diag(elements, domain)[source]
 
Return a diagonal matrix.

 

 
 

 

-diagonal()[source]

+diagonal()[source]
 
Return the diagonal of a DFM matrix.

 

 
 

 

-extract(rowslist, colslist)[source]

+extract(rowslist, colslist)[source]
 
Extract a submatrix.

 

 
 

 

-extract_slice(rowslice, colslice)[source]

+extract_slice(rowslice, colslice)[source]
 
Slice a DFM.

 

 
 

 

-classmethod eye(n, domain)[source]

+classmethod eye(n, domain)[source]
 
Return the identity matrix of size n.

 

 
 

 

-classmethod from_ddm(ddm)[source]

+classmethod from_ddm(ddm)[source]
 
Convert from a DDM.

 

 
 

 

-classmethod from_dod(dod, shape, domain)[source]

+classmethod from_dod(dod, shape, domain)[source]
 
Inverse of to_dod().

 

 
 

 

-classmethod from_dok(dok, shape, domain)[source]

+classmethod from_dok(dok, shape, domain)[source]
 
Inverse of \(to_dod\).

 

 
 

 

-classmethod from_flat_nz(elements, data, domain)[source]

+classmethod from_flat_nz(elements, data, domain)[source]
 
Inverse of to_flat_nz().

 

 
 

 

-classmethod from_list(rowslist, shape, domain)[source]

+classmethod from_list(rowslist, shape, domain)[source]
 
Construct from a nested list.

 

 
 

 

-classmethod from_list_flat(elements, shape, domain)[source]

+classmethod from_list_flat(elements, shape, domain)[source]
 
Inverse of to_list_flat().

 

 
 

 

-getitem(i, j)[source]

+getitem(i, j)[source]
 
Get the (i, j)-th entry.

 

 
 

 

-hstack(*others)[source]

+hstack(*others)[source]
 
Horizontally stack matrices.

 

 
 

 

-inv()[source]

+inv()[source]
 
Compute the inverse of a matrix using FLINT.

 
Examples

 
>>> from sympy import Matrix, QQ
@@ -5974,43 +5974,43 @@ 
What is domainmatrix?
 

-is_diagonal()[source]

+is_diagonal()[source]
 
Return True if the matrix is diagonal.

 

 
 

 

-is_lower()[source]

+is_lower()[source]
 
Return True if the matrix is lower triangular.

 

 
 

 

-is_upper()[source]

+is_upper()[source]
 
Return True if the matrix is upper triangular.

 

 
 

 

-is_zero_matrix()[source]

+is_zero_matrix()[source]
 
Return True if the matrix is the zero matrix.

 

 
 

 

-iter_items()[source]

+iter_items()[source]
 
Iterate over indices and values of nonzero elements of the matrix.

 

 
 

 

-iter_values()[source]

+iter_values()[source]
 
Iterater over the non-zero values of the matrix.

 

 
 

 

-lll(delta=0.75)[source]

+lll(delta=0.75)[source]
 
Compute LLL-reduced basis using FLINT.

 
See lll_transform() for more information.

 
Examples

@@ -6033,7 +6033,7 @@ 
What is domainmatrix?
 

-lll_transform(delta=0.75)[source]

+lll_transform(delta=0.75)[source]
 
Compute LLL-reduced basis and transform using FLINT.

 
Examples

 
>>> from sympy import Matrix
@@ -6060,13 +6060,13 @@ 
What is domainmatrix?
 

-lu()[source]

+lu()[source]
 
Return the LU decomposition of the matrix.

 

 
 

 

-lu_solve(rhs)[source]

+lu_solve(rhs)[source]
 
Solve a matrix equation using FLINT.

 
Examples

 
>>> from sympy import Matrix, QQ
@@ -6109,97 +6109,97 @@ 
What is domainmatrix?
 

-matmul(other)[source]

+matmul(other)[source]
 
Multiply two DFM matrices.

 

 
 

 

-mul(other)[source]

+mul(other)[source]
 
Multiply a DFM matrix from the right by a scalar.

 

 
 

 

-mul_elementwise(other)[source]

+mul_elementwise(other)[source]
 
Elementwise multiplication of two DFM matrices.

 

 
 

 

-neg()[source]

+neg()[source]
 
Negate a DFM matrix.

 

 
 

 

-nnz()[source]

+nnz()[source]
 
Return the number of non-zero elements in the matrix.

 

 
 

 

-nullspace()[source]

+nullspace()[source]
 
Return a basis for the nullspace of the matrix.

 

 
 

 

-nullspace_from_rref(pivots=None)[source]

+nullspace_from_rref(pivots=None)[source]
 
Return a basis for the nullspace of the matrix.

 

 
 

 

-classmethod ones(shape, domain)[source]

+classmethod ones(shape, domain)[source]
 
Return a one DFM matrix.

 

 
 

 

-particular()[source]

+particular()[source]
 
Return a particular solution to the system.

 

 
 

 

-rmul(other)[source]

+rmul(other)[source]
 
Multiply a DFM matrix from the left by a scalar.

 

 
 

 

-scc()[source]

+scc()[source]
 
Return the strongly connected components of the matrix.

 

 
 

 

-setitem(i, j, value)[source]

+setitem(i, j, value)[source]
 
Set the (i, j)-th entry.

 

 
 

 

-sub(other)[source]

+sub(other)[source]
 
Subtract two DFM matrices.

 

 
 

 

-to_ddm()[source]

+to_ddm()[source]
 
Convert to a DDM.

 

 
 

 

-to_dfm()[source]

+to_dfm()[source]
 
Return self.

 

 
 

 

-to_dfm_or_ddm()[source]

+to_dfm_or_ddm()[source]
 
Convert to a DFM.

 
This DFM method exists to parallel the DDM and
 SDM methods. For DFM it will always return self.

@@ -6211,55 +6211,55 @@ 
What is domainmatrix?
 

-to_dod()[source]

+to_dod()[source]
 
Convert to a DOD.

 

 
 

 

-to_dok()[source]

+to_dok()[source]
 
Convert to a DOK.

 

 
 

 

-to_flat_nz()[source]

+to_flat_nz()[source]
 
Convert to a flat list of non-zeros.

 

 
 

 

-to_list()[source]

+to_list()[source]
 
Convert to a nested list.

 

 
 

 

-to_list_flat()[source]

+to_list_flat()[source]
 
Convert to a flat list.

 

 
 

 

-to_sdm()[source]

+to_sdm()[source]
 
Convert to a SDM.

 

 
 

 

-transpose()[source]

+transpose()[source]
 
Transpose a DFM matrix.

 

 
 

 

-vstack(*others)[source]

+vstack(*others)[source]
 
Vertically stack matrices.

 

 
 

 

-classmethod zeros(shape, domain)[source]

+classmethod zeros(shape, domain)[source]
 
Return a zero DFM matrix.

 

 
@@ -6267,7 +6267,7 @@ 
What is domainmatrix?
 

-sympy.polys.matrices.normalforms.smith_normal_form(m)[source]

+sympy.polys.matrices.normalforms.smith_normal_form(m)[source]
 
Return the Smith Normal Form of a matrix \(m\) over the ring \(domain\).
 This will only work if the ring is a principal ideal domain.

 
Examples

@@ -6294,7 +6294,7 @@ 
What is domainmatrix?check_rank=False,

 

 
-)[source]
+)[source]
 
Compute the Hermite Normal Form of DomainMatrix A over
 ZZ.

 

diff --git a/dev/modules/polys/domainsref.html b/dev/modules/polys/domainsref.html
index 892f3f15787..1dd5a8a6d7a 100644
--- a/dev/modules/polys/domainsref.html
+++ b/dev/modules/polys/domainsref.html
@@ -827,7 +827,7 @@ 
Domains
Abstract Domains

 

 

-class sympy.polys.domains.domain.Domain[source]

+class sympy.polys.domains.domain.Domain[source]
 
Superclass for all domains in the polys domains system.

 
See Introducing the Domains of the poly module for an introductory explanation of the
 domains system.

@@ -998,13 +998,13 @@ 
Abstract Domains
 

-abs(a)[source]

+abs(a)[source]
 
Absolute value of a, implies __abs__.

 

 
 

 

-add(a, b)[source]

+add(a, b)[source]
 
Sum of a and b, implies __add__.

 

 
@@ -1018,7 +1018,7 @@ 
Abstract Domainsroot_index=-1,

 

 
-)[source]
+)[source]
 
Convenience method to construct an algebraic extension on a root of a
 polynomial, chosen by root index.

 

@@ -1061,37 +1061,37 @@ 
Abstract Domains
 

-algebraic_field(*extension, alias=None)[source]

+algebraic_field(*extension, alias=None)[source]
 
Returns an algebraic field, i.e. \(K(\alpha, \ldots)\).

 

 
 

 

-almosteq(a, b, tolerance=None)[source]

+almosteq(a, b, tolerance=None)[source]
 
Check if a and b are almost equal.

 

 
 

 

-characteristic()[source]

+characteristic()[source]
 
Return the characteristic of this domain.

 

 
 

 

-cofactors(a, b)[source]

+cofactors(a, b)[source]
 
Returns GCD and cofactors of a and b.

 

 
 

 

-convert(element, base=None)[source]

+convert(element, base=None)[source]
 
Convert element to self.dtype.

 

 
 

 

-convert_from(element, base)[source]

+convert_from(element, base)[source]
 
Convert element to self.dtype given the base domain.

 

 
@@ -1107,7 +1107,7 @@ 
Abstract Domainsroot_index=-1,

 

 
-)[source]
+)[source]
 
Convenience method to construct a cyclotomic field.

 

 
Parameters:

@@ -1153,13 +1153,13 @@ 
Abstract Domains
 

-denom(a)[source]

+denom(a)[source]
 
Returns denominator of a.

 

 
 

 

-div(a, b)[source]

+div(a, b)[source]
 
Quotient and remainder for a and b. Analogue of divmod(a, b)

 

 
Parameters:

@@ -1241,7 +1241,7 @@ 
Abstract Domains
 

-drop(*symbols)[source]

+drop(*symbols)[source]
 
Drop generators from this domain.

 

 
@@ -1271,13 +1271,13 @@ 
Abstract Domains
 

-evalf(a, prec=None, **options)[source]

+evalf(a, prec=None, **options)[source]
 
Returns numerical approximation of a.

 

 
 

 

-exquo(a, b)[source]

+exquo(a, b)[source]
 
Exact quotient of a and b. Analogue of a / b.

 

 
Parameters:

@@ -1365,7 +1365,7 @@ 
Abstract Domains
 

-exsqrt(a)[source]

+exsqrt(a)[source]
 
Principal square root of a within the domain if a is square.

 
Explanation

 
The implementation of this method should return an element b in the
@@ -1381,109 +1381,109 @@ 
Abstract Domains
 

-frac_field(*symbols, order=LexOrder())[source]

+frac_field(*symbols, order=LexOrder())[source]
 
Returns a fraction field, i.e. \(K(X)\).

 

 
 

 

-from_AlgebraicField(a, K0)[source]

+from_AlgebraicField(a, K0)[source]
 
Convert an algebraic number to dtype.

 

 
 

 

-from_ComplexField(a, K0)[source]

+from_ComplexField(a, K0)[source]
 
Convert a complex element to dtype.

 

 
 

 

-from_ExpressionDomain(a, K0)[source]

+from_ExpressionDomain(a, K0)[source]
 
Convert a EX object to dtype.

 

 
 

 

-from_ExpressionRawDomain(a, K0)[source]

+from_ExpressionRawDomain(a, K0)[source]
 
Convert a EX object to dtype.

 

 
 

 

-from_FF(a, K0)[source]

+from_FF(a, K0)[source]
 
Convert ModularInteger(int) to dtype.

 

 
 

 

-from_FF_gmpy(a, K0)[source]

+from_FF_gmpy(a, K0)[source]
 
Convert ModularInteger(mpz) to dtype.

 

 
 

 

-from_FF_python(a, K0)[source]

+from_FF_python(a, K0)[source]
 
Convert ModularInteger(int) to dtype.

 

 
 

 

-from_FractionField(a, K0)[source]

+from_FractionField(a, K0)[source]
 
Convert a rational function to dtype.

 

 
 

 

-from_GlobalPolynomialRing(a, K0)[source]

+from_GlobalPolynomialRing(a, K0)[source]
 
Convert a polynomial to dtype.

 

 
 

 

-from_MonogenicFiniteExtension(a, K0)[source]

+from_MonogenicFiniteExtension(a, K0)[source]
 
Convert an ExtensionElement to dtype.

 

 
 

 

-from_PolynomialRing(a, K0)[source]

+from_PolynomialRing(a, K0)[source]
 
Convert a polynomial to dtype.

 

 
 

 

-from_QQ_gmpy(a, K0)[source]

+from_QQ_gmpy(a, K0)[source]
 
Convert a GMPY mpq object to dtype.

 

 
 

 

-from_QQ_python(a, K0)[source]

+from_QQ_python(a, K0)[source]
 
Convert a Python Fraction object to dtype.

 

 
 

 

-from_RealField(a, K0)[source]

+from_RealField(a, K0)[source]
 
Convert a real element object to dtype.

 

 
 

 

-from_ZZ_gmpy(a, K0)[source]

+from_ZZ_gmpy(a, K0)[source]
 
Convert a GMPY mpz object to dtype.

 

 
 

 

-from_ZZ_python(a, K0)[source]

+from_ZZ_python(a, K0)[source]
 
Convert a Python int object to dtype.

 

 
 

 

-from_sympy(a)[source]

+from_sympy(a)[source]
 
Convert a SymPy expression to an element of this domain.

 

 
Parameters:

@@ -1509,37 +1509,37 @@ 
Abstract Domains
 

-gcd(a, b)[source]

+gcd(a, b)[source]
 
Returns GCD of a and b.

 

 
 

 

-gcdex(a, b)[source]

+gcdex(a, b)[source]
 
Extended GCD of a and b.

 

 
 

 

-get_exact()[source]

+get_exact()[source]
 
Returns an exact domain associated with self.

 

 
 

 

-get_field()[source]

+get_field()[source]
 
Returns a field associated with self.

 

 
 

 

-get_ring()[source]

+get_ring()[source]
 
Returns a ring associated with self.

 

 
 

 

-half_gcdex(a, b)[source]

+half_gcdex(a, b)[source]
 
Half extended GCD of a and b.

 

 
@@ -1581,13 +1581,13 @@ 
Abstract Domains
 

-inject(*symbols)[source]

+inject(*symbols)[source]
 
Inject generators into this domain.

 

 
 

 

-invert(a, b)[source]

+invert(a, b)[source]
 
Returns inversion of a mod b, implies something.

 

 
@@ -1644,37 +1644,37 @@ 
Abstract Domains
 

-is_negative(a)[source]

+is_negative(a)[source]
 
Returns True if a is negative.

 

 
 

 

-is_nonnegative(a)[source]

+is_nonnegative(a)[source]
 
Returns True if a is non-negative.

 

 
 

 

-is_nonpositive(a)[source]

+is_nonpositive(a)[source]
 
Returns True if a is non-positive.

 

 
 

 

-is_one(a)[source]

+is_one(a)[source]
 
Returns True if a is one.

 

 
 

 

-is_positive(a)[source]

+is_positive(a)[source]
 
Returns True if a is positive.

 

 
 

 

-is_square(a)[source]

+is_square(a)[source]
 
Returns whether a is a square in the domain.

 
Explanation

 
Returns True if there is an element b in the domain such that
@@ -1689,67 +1689,67 @@ 
Abstract Domains
 

-is_zero(a)[source]

+is_zero(a)[source]
 
Returns True if a is zero.

 

 
 

 

-lcm(a, b)[source]

+lcm(a, b)[source]
 
Returns LCM of a and b.

 

 
 

 

-log(a, b)[source]

+log(a, b)[source]
 
Returns b-base logarithm of a.

 

 
 

 

-map(seq)[source]

+map(seq)[source]
 
Rersively apply self to all elements of seq.

 

 
 

 

-mul(a, b)[source]

+mul(a, b)[source]
 
Product of a and b, implies __mul__.

 

 
 

 

-n(a, prec=None, **options)[source]

+n(a, prec=None, **options)[source]
 
Returns numerical approximation of a.

 

 
 

 

-neg(a)[source]

+neg(a)[source]
 
Returns a negated, implies __neg__.

 

 
 

 

-numer(a)[source]

+numer(a)[source]
 
Returns numerator of a.

 

 
 

 

-of_type(element)[source]

+of_type(element)[source]
 
Check if a is of type dtype.

 

 
 

 

-old_frac_field(*symbols, **kwargs)[source]

+old_frac_field(*symbols, **kwargs)[source]
 
Returns a fraction field, i.e. \(K(X)\).

 

 
 

 

-old_poly_ring(*symbols, **kwargs)[source]

+old_poly_ring(*symbols, **kwargs)[source]
 
Returns a polynomial ring, i.e. \(K[X]\).

 

 
@@ -1772,25 +1772,25 @@ 
Abstract Domains
 

-poly_ring(*symbols, order=LexOrder())[source]

+poly_ring(*symbols, order=LexOrder())[source]
 
Returns a polynomial ring, i.e. \(K[X]\).

 

 
 

 

-pos(a)[source]

+pos(a)[source]
 
Returns a positive, implies __pos__.

 

 
 

 

-pow(a, b)[source]

+pow(a, b)[source]
 
Raise a to power b, implies __pow__.

 

 
 

 

-quo(a, b)[source]

+quo(a, b)[source]
 
Quotient of a and b. Analogue of a // b.

 
K.quo(a, b) is equivalent to K.div(a, b)[0]. See
 div() for more explanation.

@@ -1809,7 +1809,7 @@ 
Abstract Domains
 

-rem(a, b)[source]

+rem(a, b)[source]
 
Modulo division of a and b. Analogue of a % b.

 
K.rem(a, b) is equivalent to K.div(a, b)[1]. See
 div() for more explanation.

@@ -1828,13 +1828,13 @@ 
Abstract Domains
 

-revert(a)[source]

+revert(a)[source]
 
Returns a**(-1) if possible.

 

 
 

 

-sqrt(a)[source]

+sqrt(a)[source]
 
Returns a (possibly inexact) square root of a.

 
Explanation

 
There is no universal definition of “inexact square root” for all
@@ -1848,13 +1848,13 @@ 
Abstract Domains
 

-sub(a, b)[source]

+sub(a, b)[source]
 
Difference of a and b, implies __sub__.

 

 
 

 

-to_sympy(a)[source]

+to_sympy(a)[source]
 
Convert domain element a to a SymPy expression (Expr).

 

 
Parameters:

@@ -1949,7 +1949,7 @@ 
Abstract Domains
 

-unify(K1, symbols=None)[source]

+unify(K1, symbols=None)[source]
 
Construct a minimal domain that contains elements of K0 and K1.

 
Known domains (from smallest to largest):

 

 
@@ -1992,13 +1992,13 @@ 
Abstract Domains
 

-class sympy.polys.domains.domainelement.DomainElement[source]

+class sympy.polys.domains.domainelement.DomainElement[source]
 
Represents an element of a domain.

 
Mix in this trait into a class whose instances should be recognized as
 elements of a domain. Method parent() gives that domain.

 

 

-parent()[source]

+parent()[source]
 
Get the domain associated with self

 
Examples

 
>>> from sympy import ZZ, symbols
@@ -2020,23 +2020,23 @@ 
Abstract Domains
 

-class sympy.polys.domains.field.Field[source]

+class sympy.polys.domains.field.Field[source]
 
Represents a field domain.

 

 

-div(a, b)[source]

+div(a, b)[source]
 
Division of a and b, implies __truediv__.

 

 
 

 

-exquo(a, b)[source]

+exquo(a, b)[source]
 
Exact quotient of a and b, implies __truediv__.

 

 
 

 

-gcd(a, b)[source]

+gcd(a, b)[source]
 
Returns GCD of a and b.

 
This definition of GCD over fields allows to clear denominators
 in \(primitive()\).

@@ -2058,31 +2058,31 @@ 
Abstract Domains
 

-gcdex(a, b)[source]

+gcdex(a, b)[source]
 
Returns x, y, g such that a * x + b * y == g == gcd(a, b)

 

 
 

 

-get_field()[source]

+get_field()[source]
 
Returns a field associated with self.

 

 
 

 

-get_ring()[source]

+get_ring()[source]
 
Returns a ring associated with self.

 

 
 

 

-is_unit(a)[source]

+is_unit(a)[source]
 
Return true if a is a invertible

 

 
 

 

-lcm(a, b)[source]

+lcm(a, b)[source]
 
Returns LCM of a and b.

 
>>> from sympy.polys.domains import QQ
 >>> from sympy import S, lcm
@@ -2098,19 +2098,19 @@ 
Abstract Domains
 

-quo(a, b)[source]

+quo(a, b)[source]
 
Quotient of a and b, implies __truediv__.

 

 
 

 

-rem(a, b)[source]

+rem(a, b)[source]
 
Remainder of a and b, implies nothing.

 

 
 

 

-revert(a)[source]

+revert(a)[source]
 
Returns a**(-1) if possible.

 

 
@@ -2118,29 +2118,29 @@ 
Abstract Domains
 

-class sympy.polys.domains.ring.Ring[source]

+class sympy.polys.domains.ring.Ring[source]
 
Represents a ring domain.

 

 

-denom(a)[source]

+denom(a)[source]
 
Returns denominator of \(a\).

 

 
 

 

-div(a, b)[source]

+div(a, b)[source]
 
Division of a and b, implies __divmod__.

 

 
 

 

-exquo(a, b)[source]

+exquo(a, b)[source]
 
Exact quotient of a and b, implies __floordiv__.

 

 
 

 

-free_module(rank)[source]

+free_module(rank)[source]
 
Generate a free module of rank rank over self.

 
>>> from sympy.abc import x
 >>> from sympy import QQ
@@ -2152,13 +2152,13 @@ 
Abstract Domains
 

-get_ring()[source]

+get_ring()[source]
 
Returns a ring associated with self.

 

 
 

 

-ideal(*gens)[source]

+ideal(*gens)[source]
 
Generate an ideal of self.

 
>>> from sympy.abc import x
 >>> from sympy import QQ
@@ -2170,25 +2170,25 @@ 
Abstract Domains
 

-invert(a, b)[source]

+invert(a, b)[source]
 
Returns inversion of a mod b.

 

 
 

 

-numer(a)[source]

+numer(a)[source]
 
Returns numerator of a.

 

 
 

 

-quo(a, b)[source]

+quo(a, b)[source]
 
Quotient of a and b, implies __floordiv__.

 

 
 

 

-quotient_ring(e)[source]

+quotient_ring(e)[source]
 
Form a quotient ring of self.

 
Here e can be an ideal or an iterable.

 
>>> from sympy.abc import x
@@ -2208,13 +2208,13 @@ 
Abstract Domains
 

-rem(a, b)[source]

+rem(a, b)[source]
 
Remainder of a and b, implies __mod__.

 

 
 

 

-revert(a)[source]

+revert(a)[source]
 
Returns a**(-1) if possible.

 

 
@@ -2222,11 +2222,11 @@ 
Abstract Domains
 

-class sympy.polys.domains.simpledomain.SimpleDomain[source]

+class sympy.polys.domains.simpledomain.SimpleDomain[source]
 
Base class for simple domains, e.g. ZZ, QQ.

 

 

-inject(*gens)[source]

+inject(*gens)[source]
 
Inject generators into this domain.

 

 
@@ -2234,23 +2234,23 @@ 
Abstract Domains
 

-class sympy.polys.domains.compositedomain.CompositeDomain[source]

+class sympy.polys.domains.compositedomain.CompositeDomain[source]
 
Base class for composite domains, e.g. ZZ[x], ZZ(X).

 

 

-drop(*symbols)[source]

+drop(*symbols)[source]
 
Drop generators from this domain.

 

 
 

 

-get_exact()[source]

+get_exact()[source]
 
Returns an exact version of this domain.

 

 
 

 

-inject(*symbols)[source]

+inject(*symbols)[source]
 
Inject generators into this domain.

 

 
@@ -2262,7 +2262,7 @@ 
Abstract Domains
 

-set_domain(domain)[source]

+set_domain(domain)[source]
 
Set the ground domain of this domain.

 

 
@@ -2273,7 +2273,7 @@ 
Abstract Domains
GF(p)

 

 

-class sympy.polys.domains.FiniteField(mod, symmetric=True)[source]

+class sympy.polys.domains.FiniteField(mod, symmetric=True)[source]
 
Finite field of prime order GF(p)

 
A GF(p) domain represents a finite field \(\mathbb{F}_p\) of prime
 order as Domain in the domain system (see
@@ -2356,13 +2356,13 @@ 
Abstract DomainsGF(p**n)) but these are not yet implemented in SymPY.

 

 

-characteristic()[source]

+characteristic()[source]
 
Return the characteristic of this domain.

 

 
 

 

-exsqrt(a)[source]

+exsqrt(a)[source]
 
Square root modulo p of a if it is a quadratic residue.

 
Explanation

 
Always returns the square root that is no larger than p // 2.

@@ -2370,115 +2370,115 @@ 
Abstract Domains
 

-from_FF(a, K0=None)[source]

+from_FF(a, K0=None)[source]
 
Convert ModularInteger(int) to dtype.

 

 
 

 

-from_FF_gmpy(a, K0=None)[source]

+from_FF_gmpy(a, K0=None)[source]
 
Convert ModularInteger(mpz) to dtype.

 

 
 

 

-from_FF_python(a, K0=None)[source]

+from_FF_python(a, K0=None)[source]
 
Convert ModularInteger(int) to dtype.

 

 
 

 

-from_QQ(a, K0=None)[source]

+from_QQ(a, K0=None)[source]
 
Convert Python’s Fraction to dtype.

 

 
 

 

-from_QQ_gmpy(a, K0=None)[source]

+from_QQ_gmpy(a, K0=None)[source]
 
Convert GMPY’s mpq to dtype.

 

 
 

 

-from_QQ_python(a, K0=None)[source]

+from_QQ_python(a, K0=None)[source]
 
Convert Python’s Fraction to dtype.

 

 
 

 

-from_RealField(a, K0)[source]

+from_RealField(a, K0)[source]
 
Convert mpmath’s mpf to dtype.

 

 
 

 

-from_ZZ(a, K0=None)[source]

+from_ZZ(a, K0=None)[source]
 
Convert Python’s int to dtype.

 

 
 

 

-from_ZZ_gmpy(a, K0=None)[source]

+from_ZZ_gmpy(a, K0=None)[source]
 
Convert GMPY’s mpz to dtype.

 

 
 

 

-from_ZZ_python(a, K0=None)[source]

+from_ZZ_python(a, K0=None)[source]
 
Convert Python’s int to dtype.

 

 
 

 

-from_sympy(a)[source]

+from_sympy(a)[source]
 
Convert SymPy’s Integer to SymPy’s Integer.

 

 
 

 

-get_field()[source]

+get_field()[source]
 
Returns a field associated with self.

 

 
 

 

-is_negative(a)[source]

+is_negative(a)[source]
 
Returns True if a is negative.

 

 
 

 

-is_nonnegative(a)[source]

+is_nonnegative(a)[source]
 
Returns True if a is non-negative.

 

 
 

 

-is_nonpositive(a)[source]

+is_nonpositive(a)[source]
 
Returns True if a is non-positive.

 

 
 

 

-is_positive(a)[source]

+is_positive(a)[source]
 
Returns True if a is positive.

 

 
 

 

-is_square(a)[source]

+is_square(a)[source]
 
Returns True if a is a quadratic residue modulo p.

 

 
 

 

-to_int(a)[source]

+to_int(a)[source]
 
Convert val to a Python int object.

 

 
 

 

-to_sympy(a)[source]

+to_sympy(a)[source]
 
Convert a to a SymPy object.

 

 
@@ -2486,13 +2486,13 @@ 
Abstract Domains
 

-class sympy.polys.domains.PythonFiniteField(mod, symmetric=True)[source]

+class sympy.polys.domains.PythonFiniteField(mod, symmetric=True)[source]
 
Finite field based on Python’s integers.

 

 
 

 

-class sympy.polys.domains.GMPYFiniteField(mod, symmetric=True)[source]

+class sympy.polys.domains.GMPYFiniteField(mod, symmetric=True)[source]
 
Finite field based on GMPY integers.

 

 
@@ -2548,7 +2548,7 @@ 
Abstract Domains
 

-class sympy.polys.domains.IntegerRing[source]

+class sympy.polys.domains.IntegerRing[source]
 
The domain ZZ representing the integers \(\mathbb{Z}\).

 
The IntegerRing class represents the ring of integers as a
 Domain in the domain system. IntegerRing is a
@@ -2568,7 +2568,7 @@ 
Abstract Domainsalias=None,

 

 
-)[source]
+)[source]
 
Returns an algebraic field, i.e. \(\mathbb{Q}(\alpha, \ldots)\).

 

 
Parameters:

@@ -2600,7 +2600,7 @@ 
Abstract Domains
 

-exsqrt(a)[source]

+exsqrt(a)[source]
 
Non-negative square root of a if a is a square.

 

 
See also

@@ -2610,104 +2610,104 @@ 
Abstract Domains
 

-factorial(a)[source]

+factorial(a)[source]
 
Compute factorial of a.

 

 
 

 

-from_AlgebraicField(a, K0)[source]

+from_AlgebraicField(a, K0)[source]
 
Convert a ANP object to ZZ.

 
See convert().

 

 
 

 

-from_EX(a, K0)[source]

+from_EX(a, K0)[source]
 
Convert Expression to GMPY’s mpz.

 

 
 

 

-from_FF(a, K0)[source]

+from_FF(a, K0)[source]
 
Convert ModularInteger(int) to GMPY’s mpz.

 

 
 

 

-from_FF_gmpy(a, K0)[source]

+from_FF_gmpy(a, K0)[source]
 
Convert ModularInteger(mpz) to GMPY’s mpz.

 

 
 

 

-from_FF_python(a, K0)[source]

+from_FF_python(a, K0)[source]
 
Convert ModularInteger(int) to GMPY’s mpz.

 

 
 

 

-from_QQ(a, K0)[source]

+from_QQ(a, K0)[source]
 
Convert Python’s Fraction to GMPY’s mpz.

 

 
 

 

-from_QQ_gmpy(a, K0)[source]

+from_QQ_gmpy(a, K0)[source]
 
Convert GMPY mpq to GMPY’s mpz.

 

 
 

 

-from_QQ_python(a, K0)[source]

+from_QQ_python(a, K0)[source]
 
Convert Python’s Fraction to GMPY’s mpz.

 

 
 

 

-from_RealField(a, K0)[source]

+from_RealField(a, K0)[source]
 
Convert mpmath’s mpf to GMPY’s mpz.

 

 
 

 

-from_ZZ(a, K0)[source]

+from_ZZ(a, K0)[source]
 
Convert Python’s int to GMPY’s mpz.

 

 
 

 

-from_ZZ_gmpy(a, K0)[source]

+from_ZZ_gmpy(a, K0)[source]
 
Convert GMPY’s mpz to GMPY’s mpz.

 

 
 

 

-from_ZZ_python(a, K0)[source]

+from_ZZ_python(a, K0)[source]
 
Convert Python’s int to GMPY’s mpz.

 

 
 

 

-from_sympy(a)[source]

+from_sympy(a)[source]
 
Convert SymPy’s Integer to dtype.

 

 
 

 

-gcd(a, b)[source]

+gcd(a, b)[source]
 
Compute GCD of a and b.

 

 
 

 

-gcdex(a, b)[source]

+gcdex(a, b)[source]
 
Compute extended GCD of a and b.

 

 
 

 

-get_field()[source]

+get_field()[source]
 
Return the associated field of fractions QQ

 

 
Returns:

@@ -2729,7 +2729,7 @@ 
Abstract Domains
 

-is_square(a)[source]

+is_square(a)[source]
 
Return True if a is a square.

 
Explanation

 
An integer is a square if and only if there exists an integer
@@ -2738,13 +2738,13 @@ 
Abstract Domains
 

-lcm(a, b)[source]

+lcm(a, b)[source]
 
Compute LCM of a and b.

 

 
 

 

-log(a, b)[source]

+log(a, b)[source]
 
Logarithm of a to the base b.

 

 
Parameters:

@@ -2773,13 +2773,13 @@ 
Abstract Domains
 

-sqrt(a)[source]

+sqrt(a)[source]
 
Compute square root of a.

 

 
 

 

-to_sympy(a)[source]

+to_sympy(a)[source]
 
Convert a to a SymPy object.

 

 
@@ -2787,7 +2787,7 @@ 
Abstract Domains
 

-class sympy.polys.domains.PythonIntegerRing[source]

+class sympy.polys.domains.PythonIntegerRing[source]
 
Integer ring based on Python’s int type.

 
This will be used as ZZ if gmpy and gmpy2 are not
 installed. Elements are instances of the standard Python int type.

@@ -2795,97 +2795,97 @@ 
Abstract Domains
 

-class sympy.polys.domains.GMPYIntegerRing[source]

+class sympy.polys.domains.GMPYIntegerRing[source]
 
Integer ring based on GMPY’s mpz type.

 
This will be the implementation of ZZ if gmpy or gmpy2 is
 installed. Elements will be of type gmpy.mpz.

 

 

-factorial(a)[source]

+factorial(a)[source]
 
Compute factorial of a.

 

 
 

 

-from_FF_gmpy(a, K0)[source]

+from_FF_gmpy(a, K0)[source]
 
Convert ModularInteger(mpz) to GMPY’s mpz.

 

 
 

 

-from_FF_python(a, K0)[source]

+from_FF_python(a, K0)[source]
 
Convert ModularInteger(int) to GMPY’s mpz.

 

 
 

 

-from_QQ(a, K0)[source]

+from_QQ(a, K0)[source]
 
Convert Python’s Fraction to GMPY’s mpz.

 

 
 

 

-from_QQ_gmpy(a, K0)[source]

+from_QQ_gmpy(a, K0)[source]
 
Convert GMPY mpq to GMPY’s mpz.

 

 
 

 

-from_QQ_python(a, K0)[source]

+from_QQ_python(a, K0)[source]
 
Convert Python’s Fraction to GMPY’s mpz.

 

 
 

 

-from_RealField(a, K0)[source]

+from_RealField(a, K0)[source]
 
Convert mpmath’s mpf to GMPY’s mpz.

 

 
 

 

-from_ZZ_gmpy(a, K0)[source]

+from_ZZ_gmpy(a, K0)[source]
 
Convert GMPY’s mpz to GMPY’s mpz.

 

 
 

 

-from_ZZ_python(a, K0)[source]

+from_ZZ_python(a, K0)[source]
 
Convert Python’s int to GMPY’s mpz.

 

 
 

 

-from_sympy(a)[source]

+from_sympy(a)[source]
 
Convert SymPy’s Integer to dtype.

 

 
 

 

-gcd(a, b)[source]

+gcd(a, b)[source]
 
Compute GCD of a and b.

 

 
 

 

-gcdex(a, b)[source]

+gcdex(a, b)[source]
 
Compute extended GCD of a and b.

 

 
 

 

-lcm(a, b)[source]

+lcm(a, b)[source]
 
Compute LCM of a and b.

 

 
 

 

-sqrt(a)[source]

+sqrt(a)[source]
 
Compute square root of a.

 

 
 

 

-to_sympy(a)[source]

+to_sympy(a)[source]
 
Convert a to a SymPy object.

 

 
@@ -2935,7 +2935,7 @@ 
Abstract Domains
 

-class sympy.polys.domains.RationalField[source]

+class sympy.polys.domains.RationalField[source]
 
Abstract base class for the domain QQ.

 
The RationalField class represents the field of rational
 numbers \(\mathbb{Q}\) as a Domain in the domain system.
@@ -2956,7 +2956,7 @@ 
Abstract Domainsalias=None,

 

 
-)[source]
+)[source]
 
Returns an algebraic field, i.e. \(\mathbb{Q}(\alpha, \ldots)\).

 

 
Parameters:

@@ -2988,25 +2988,25 @@ 
Abstract Domains
 

-denom(a)[source]

+denom(a)[source]
 
Returns denominator of a.

 

 
 

 

-div(a, b)[source]

+div(a, b)[source]
 
Division of a and b, implies __truediv__.

 

 
 

 

-exquo(a, b)[source]

+exquo(a, b)[source]
 
Exact quotient of a and b, implies __truediv__.

 

 
 

 

-exsqrt(a)[source]

+exsqrt(a)[source]
 
Non-negative square root of a if a is a square.

 

 
See also

@@ -3016,74 +3016,74 @@ 
Abstract Domains
 

-from_AlgebraicField(a, K0)[source]

+from_AlgebraicField(a, K0)[source]
 
Convert a ANP object to QQ.

 
See convert()

 

 
 

 

-from_GaussianRationalField(a, K0)[source]

+from_GaussianRationalField(a, K0)[source]
 
Convert a GaussianElement object to dtype.

 

 
 

 

-from_QQ(a, K0)[source]

+from_QQ(a, K0)[source]
 
Convert a Python Fraction object to dtype.

 

 
 

 

-from_QQ_gmpy(a, K0)[source]

+from_QQ_gmpy(a, K0)[source]
 
Convert a GMPY mpq object to dtype.

 

 
 

 

-from_QQ_python(a, K0)[source]

+from_QQ_python(a, K0)[source]
 
Convert a Python Fraction object to dtype.

 

 
 

 

-from_RealField(a, K0)[source]

+from_RealField(a, K0)[source]
 
Convert a mpmath mpf object to dtype.

 

 
 

 

-from_ZZ(a, K0)[source]

+from_ZZ(a, K0)[source]
 
Convert a Python int object to dtype.

 

 
 

 

-from_ZZ_gmpy(a, K0)[source]

+from_ZZ_gmpy(a, K0)[source]
 
Convert a GMPY mpz object to dtype.

 

 
 

 

-from_ZZ_python(a, K0)[source]

+from_ZZ_python(a, K0)[source]
 
Convert a Python int object to dtype.

 

 
 

 

-from_sympy(a)[source]

+from_sympy(a)[source]
 
Convert SymPy’s Integer to dtype.

 

 
 

 

-get_ring()[source]

+get_ring()[source]
 
Returns ring associated with self.

 

 
 

 

-is_square(a)[source]

+is_square(a)[source]
 
Return True if a is a square.

 
Explanation

 
A rational number is a square if and only if there exists
@@ -3092,25 +3092,25 @@ 
Abstract Domains
 

-numer(a)[source]

+numer(a)[source]
 
Returns numerator of a.

 

 
 

 

-quo(a, b)[source]

+quo(a, b)[source]
 
Quotient of a and b, implies __truediv__.

 

 
 

 

-rem(a, b)[source]

+rem(a, b)[source]
 
Remainder of a and b, implies nothing.

 

 
 

 

-to_sympy(a)[source]

+to_sympy(a)[source]
 
Convert a to a SymPy object.

 

 
@@ -3118,7 +3118,7 @@ 
Abstract Domains
 

-class sympy.polys.domains.PythonRationalField[source]

+class sympy.polys.domains.PythonRationalField[source]
 
Rational field based on MPQ.

 
This will be used as QQ if gmpy and gmpy2 are not
 installed. Elements are instances of MPQ.

@@ -3126,31 +3126,31 @@ 
Abstract Domains
 

-class sympy.polys.domains.GMPYRationalField[source]

+class sympy.polys.domains.GMPYRationalField[source]
 
Rational field based on GMPY’s mpq type.

 
This will be the implementation of QQ if gmpy or gmpy2 is
 installed. Elements will be of type gmpy.mpq.

 

 

-denom(a)[source]

+denom(a)[source]
 
Returns denominator of a.

 

 
 

 

-div(a, b)[source]

+div(a, b)[source]
 
Division of a and b, implies __truediv__.

 

 
 

 

-exquo(a, b)[source]

+exquo(a, b)[source]
 
Exact quotient of a and b, implies __truediv__.

 

 
 

 

-factorial(a)[source]

+factorial(a)[source]
 
Returns factorial of a.

 

 
@@ -3163,73 +3163,73 @@ 
Abstract DomainsK0,

 

 
-)[source]
+)[source]
 
Convert a GaussianElement object to dtype.

 

 
 

 

-from_QQ_gmpy(a, K0)[source]

+from_QQ_gmpy(a, K0)[source]
 
Convert a GMPY mpq object to dtype.

 

 
 

 

-from_QQ_python(a, K0)[source]

+from_QQ_python(a, K0)[source]
 
Convert a Python Fraction object to dtype.

 

 
 

 

-from_RealField(a, K0)[source]

+from_RealField(a, K0)[source]
 
Convert a mpmath mpf object to dtype.

 

 
 

 

-from_ZZ_gmpy(a, K0)[source]

+from_ZZ_gmpy(a, K0)[source]
 
Convert a GMPY mpz object to dtype.

 

 
 

 

-from_ZZ_python(a, K0)[source]

+from_ZZ_python(a, K0)[source]
 
Convert a Python int object to dtype.

 

 
 

 

-from_sympy(a)[source]

+from_sympy(a)[source]
 
Convert SymPy’s Integer to dtype.

 

 
 

 

-get_ring()[source]

+get_ring()[source]
 
Returns ring associated with self.

 

 
 

 

-numer(a)[source]

+numer(a)[source]
 
Returns numerator of a.

 

 
 

 

-quo(a, b)[source]

+quo(a, b)[source]
 
Quotient of a and b, implies __truediv__.

 

 
 

 

-rem(a, b)[source]

+rem(a, b)[source]
 
Remainder of a and b, implies nothing.

 

 
 

 

-to_sympy(a)[source]

+to_sympy(a)[source]
 
Convert a to a SymPy object.

 

 
@@ -3237,7 +3237,7 @@ 
Abstract Domains
 

-class sympy.external.pythonmpq.PythonMPQ(numerator, denominator=None)[source]

+class sympy.external.pythonmpq.PythonMPQ(numerator, denominator=None)[source]
 
Rational number implementation that is intended to be compatible with
 gmpy2’s mpq.

 
Also slightly faster than fractions.Fraction.

@@ -3258,89 +3258,89 @@ 
Gaussian domainsGaussianDomain for the domains themselves.

 

 

-class sympy.polys.domains.gaussiandomains.GaussianDomain[source]

+class sympy.polys.domains.gaussiandomains.GaussianDomain[source]
 
Base class for Gaussian domains.

 

 

-from_AlgebraicField(a, K0)[source]

+from_AlgebraicField(a, K0)[source]
 
Convert an element from ZZ<I> or QQ<I> to self.dtype.

 

 
 

 

-from_QQ(a, K0)[source]

+from_QQ(a, K0)[source]
 
Convert a GMPY mpq to self.dtype.

 

 
 

 

-from_QQ_gmpy(a, K0)[source]

+from_QQ_gmpy(a, K0)[source]
 
Convert a GMPY mpq to self.dtype.

 

 
 

 

-from_QQ_python(a, K0)[source]

+from_QQ_python(a, K0)[source]
 
Convert a QQ_python element to self.dtype.

 

 
 

 

-from_ZZ(a, K0)[source]

+from_ZZ(a, K0)[source]
 
Convert a ZZ_python element to self.dtype.

 

 
 

 

-from_ZZ_gmpy(a, K0)[source]

+from_ZZ_gmpy(a, K0)[source]
 
Convert a GMPY mpz to self.dtype.

 

 
 

 

-from_ZZ_python(a, K0)[source]

+from_ZZ_python(a, K0)[source]
 
Convert a ZZ_python element to self.dtype.

 

 
 

 

-from_sympy(a)[source]

+from_sympy(a)[source]
 
Convert a SymPy object to self.dtype.

 

 
 

 

-inject(*gens)[source]

+inject(*gens)[source]
 
Inject generators into this domain.

 

 
 

 

-is_negative(element)[source]

+is_negative(element)[source]
 
Returns False for any GaussianElement.

 

 
 

 

-is_nonnegative(element)[source]

+is_nonnegative(element)[source]
 
Returns False for any GaussianElement.

 

 
 

 

-is_nonpositive(element)[source]

+is_nonpositive(element)[source]
 
Returns False for any GaussianElement.

 

 
 

 

-is_positive(element)[source]

+is_positive(element)[source]
 
Returns False for any GaussianElement.

 

 
 

 

-to_sympy(a)[source]

+to_sympy(a)[source]
 
Convert a to a SymPy object.

 

 
@@ -3348,23 +3348,23 @@ 
Gaussian domains
 

-class sympy.polys.domains.gaussiandomains.GaussianElement(x, y=0)[source]

+class sympy.polys.domains.gaussiandomains.GaussianElement(x, y=0)[source]
 
Base class for elements of Gaussian type domains.

 

 

-classmethod new(x, y)[source]

+classmethod new(x, y)[source]
 
Create a new GaussianElement of the same domain.

 

 
 

 

-parent()[source]

+parent()[source]
 
The domain that this is an element of (ZZ_I or QQ_I)

 

 
 

 

-quadrant()[source]

+quadrant()[source]
 
Return quadrant index 0-3.

 
0 is included in quadrant 0.

 

@@ -3376,7 +3376,7 @@ 
Gaussian domains
ZZ_I

 

 

-class sympy.polys.domains.gaussiandomains.GaussianIntegerRing[source]

+class sympy.polys.domains.gaussiandomains.GaussianIntegerRing[source]
 
Ring of Gaussian integers ZZ_I

 
The ZZ_I domain represents the Gaussian integers \(\mathbb{Z}[i]\)
 as a Domain in the domain system (see
@@ -3472,7 +3472,7 @@ 
Gaussian domains
 

-dtype[source]

+dtype[source]
 
alias of GaussianInteger

 

 
@@ -3485,7 +3485,7 @@ 
Gaussian domainsK0,

 

 
-)[source]
+)[source]
 
Convert a ZZ_I element to ZZ_I.

 

 
@@ -3498,43 +3498,43 @@ 
Gaussian domainsK0,

 

 
-)[source]
+)[source]
 
Convert a QQ_I element to ZZ_I.

 

 
 

 

-gcd(a, b)[source]

+gcd(a, b)[source]
 
Greatest common divisor of a and b over ZZ_I.

 

 
 

 

-gcdex(a, b)[source]

+gcdex(a, b)[source]
 
Return x, y, g such that x * a + y * b = g = gcd(a, b)

 

 
 

 

-get_field()[source]

+get_field()[source]
 
Returns a field associated with self.

 

 
 

 

-get_ring()[source]

+get_ring()[source]
 
Returns a ring associated with self.

 

 
 

 

-lcm(a, b)[source]

+lcm(a, b)[source]
 
Least common multiple of a and b over ZZ_I.

 

 
 

 

-normalize(d, *args)[source]

+normalize(d, *args)[source]
 
Return first quadrant element associated with d.

 
Also multiply the other arguments by the same power of i.

 

@@ -3543,7 +3543,7 @@ 
Gaussian domains
 

-class sympy.polys.domains.gaussiandomains.GaussianInteger(x, y=0)[source]

+class sympy.polys.domains.gaussiandomains.GaussianInteger(x, y=0)[source]
 
Gaussian integer: domain element for ZZ_I

 
>>> from sympy import ZZ_I
 >>> z = ZZ_I(2, 3)
@@ -3560,7 +3560,7 @@ 
Gaussian domains
QQ_I

 

 

-class sympy.polys.domains.gaussiandomains.GaussianRationalField[source]

+class sympy.polys.domains.gaussiandomains.GaussianRationalField[source]
 
Field of Gaussian rationals QQ_I

 
The QQ_I domain represents the Gaussian rationals \(\mathbb{Q}(i)\)
 as a Domain in the domain system (see
@@ -3675,25 +3675,25 @@ 
Gaussian domains
 

-as_AlgebraicField()[source]

+as_AlgebraicField()[source]
 
Get equivalent domain as an AlgebraicField.

 

 
 

 

-denom(a)[source]

+denom(a)[source]
 
Get the denominator of a.

 

 
 

 

-dtype[source]

+dtype[source]
 
alias of GaussianRational

 

 
 

 

-from_ComplexField(a, K0)[source]

+from_ComplexField(a, K0)[source]
 
Convert a ComplexField element to QQ_I.

 

 
@@ -3706,7 +3706,7 @@ 
Gaussian domainsK0,

 

 
-)[source]
+)[source]
 
Convert a ZZ_I element to QQ_I.

 

 
@@ -3719,25 +3719,25 @@ 
Gaussian domainsK0,

 

 
-)[source]
+)[source]
 
Convert a QQ_I element to QQ_I.

 

 
 

 

-get_field()[source]

+get_field()[source]
 
Returns a field associated with self.

 

 
 

 

-get_ring()[source]

+get_ring()[source]
 
Returns a ring associated with self.

 

 
 

 

-numer(a)[source]

+numer(a)[source]
 
Get the numerator of a.

 

 
@@ -3745,7 +3745,7 @@ 
Gaussian domains
 

-class sympy.polys.domains.gaussiandomains.GaussianRational(x, y=0)[source]

+class sympy.polys.domains.gaussiandomains.GaussianRational(x, y=0)[source]
 
Gaussian rational: domain element for QQ_I

 
>>> from sympy import QQ_I, QQ
 >>> z = QQ_I(QQ(2, 3), QQ(4, 5))
@@ -3762,7 +3762,7 @@ 
Gaussian domains
QQ<a>

 

 

-class sympy.polys.domains.AlgebraicField(dom, *ext, alias=None)[source]

+class sympy.polys.domains.AlgebraicField(dom, *ext, alias=None)[source]
 
Algebraic number field QQ<a>

 
A QQ<a> domain represents an algebraic number field
 \(\mathbb{Q}(a)\) as a Domain in the domain system (see
@@ -3987,25 +3987,25 @@ 
Gaussian domainsalias=None,

 

 
-)[source]
+)[source]
 
Returns an algebraic field, i.e. \(\mathbb{Q}(\alpha, \ldots)\).

 

 
 

 

-denom(a)[source]

+denom(a)[source]
 
Returns denominator of a.

 

 
 

 

-discriminant()[source]

+discriminant()[source]
 
Get the discriminant of the field.

 

 
 

 

-dtype[source]

+dtype[source]
 
alias of ANP

 

 
@@ -4023,67 +4023,67 @@ 
Gaussian domains
 

-from_AlgebraicField(a, K0)[source]

+from_AlgebraicField(a, K0)[source]
 
Convert AlgebraicField element ‘a’ to another AlgebraicField

 

 
 

 

-from_GaussianIntegerRing(a, K0)[source]

+from_GaussianIntegerRing(a, K0)[source]
 
Convert a GaussianInteger element ‘a’ to dtype.

 

 
 

 

-from_GaussianRationalField(a, K0)[source]

+from_GaussianRationalField(a, K0)[source]
 
Convert a GaussianRational element ‘a’ to dtype.

 

 
 

 

-from_QQ(a, K0)[source]

+from_QQ(a, K0)[source]
 
Convert a Python Fraction object to dtype.

 

 
 

 

-from_QQ_gmpy(a, K0)[source]

+from_QQ_gmpy(a, K0)[source]
 
Convert a GMPY mpq object to dtype.

 

 
 

 

-from_QQ_python(a, K0)[source]

+from_QQ_python(a, K0)[source]
 
Convert a Python Fraction object to dtype.

 

 
 

 

-from_RealField(a, K0)[source]

+from_RealField(a, K0)[source]
 
Convert a mpmath mpf object to dtype.

 

 
 

 

-from_ZZ(a, K0)[source]

+from_ZZ(a, K0)[source]
 
Convert a Python int object to dtype.

 

 
 

 

-from_ZZ_gmpy(a, K0)[source]

+from_ZZ_gmpy(a, K0)[source]
 
Convert a GMPY mpz object to dtype.

 

 
 

 

-from_ZZ_python(a, K0)[source]

+from_ZZ_python(a, K0)[source]
 
Convert a Python int object to dtype.

 

 
 

 

-from_sympy(a)[source]

+from_sympy(a)[source]
 
Convert SymPy’s expression to dtype.

 

 
@@ -4097,7 +4097,7 @@ 
Gaussian domainsrandomize=False,

 

 
-)[source]
+)[source]
 
Compute the Galois group of the Galois closure of this field.

 
Examples

 
If the field is Galois, the order of the group will equal the degree
@@ -4127,13 +4127,13 @@ 
Gaussian domains
 

-get_ring()[source]

+get_ring()[source]
 
Returns a ring associated with self.

 

 
 

 

-integral_basis(fmt=None)[source]

+integral_basis(fmt=None)[source]
 
Get an integral basis for the field.

 

 
Parameters:

@@ -4178,31 +4178,31 @@ 
Gaussian domains
 

-is_negative(a)[source]

+is_negative(a)[source]
 
Returns True if a is negative.

 

 
 

 

-is_nonnegative(a)[source]

+is_nonnegative(a)[source]
 
Returns True if a is non-negative.

 

 
 

 

-is_nonpositive(a)[source]

+is_nonpositive(a)[source]
 
Returns True if a is non-positive.

 

 
 

 

-is_positive(a)[source]

+is_positive(a)[source]
 
Returns True if a is positive.

 

 
 

 

-maximal_order()[source]

+maximal_order()[source]
 
Compute the maximal order, or ring of integers, of the field.

 

 
Returns:

@@ -4229,7 +4229,7 @@ 
Gaussian domains
 

-numer(a)[source]

+numer(a)[source]
 
Returns numerator of a.

 

 
@@ -4247,19 +4247,19 @@ 
Gaussian domains
 

-primes_above(p)[source]

+primes_above(p)[source]
 
Compute the prime ideals lying above a given rational prime p.

 

 
 

 

-to_alg_num(a)[source]

+to_alg_num(a)[source]
 
Convert a of dtype to an AlgebraicNumber.

 

 
 

 

-to_sympy(a)[source]

+to_sympy(a)[source]
 
Convert a of dtype to a SymPy object.

 

 
@@ -4270,17 +4270,17 @@ 
Gaussian domains
RR

 

 

-class sympy.polys.domains.RealField(prec=None, dps=None, tol=None)[source]

+class sympy.polys.domains.RealField(prec=None, dps=None, tol=None)[source]
 
Real numbers up to the given precision.

 

 

-almosteq(a, b, tolerance=None)[source]

+almosteq(a, b, tolerance=None)[source]
 
Check if a and b are almost equal.

 

 
 

 

-exsqrt(a)[source]

+exsqrt(a)[source]
 
Non-negative square root for a >= 0 and None otherwise.

 
Explanation

 
The square root may be slightly inaccurate due to floating point
@@ -4289,49 +4289,49 @@ 
Gaussian domains
 

-from_sympy(expr)[source]

+from_sympy(expr)[source]
 
Convert SymPy’s number to dtype.

 

 
 

 

-gcd(a, b)[source]

+gcd(a, b)[source]
 
Returns GCD of a and b.

 

 
 

 

-get_exact()[source]

+get_exact()[source]
 
Returns an exact domain associated with self.

 

 
 

 

-get_ring()[source]

+get_ring()[source]
 
Returns a ring associated with self.

 

 
 

 

-is_square(a)[source]

+is_square(a)[source]
 
Returns True if a >= 0 and False otherwise.

 

 
 

 

-lcm(a, b)[source]

+lcm(a, b)[source]
 
Returns LCM of a and b.

 

 
 

 

-to_rational(element, limit=True)[source]

+to_rational(element, limit=True)[source]
 
Convert a real number to rational number.

 

 
 

 

-to_sympy(element)[source]

+to_sympy(element)[source]
 
Convert element to SymPy number.

 

 
@@ -4342,17 +4342,17 @@ 
Gaussian domains
CC

 

 

-class sympy.polys.domains.ComplexField(prec=None, dps=None, tol=None)[source]

+class sympy.polys.domains.ComplexField(prec=None, dps=None, tol=None)[source]
 
Complex numbers up to the given precision.

 

 

-almosteq(a, b, tolerance=None)[source]

+almosteq(a, b, tolerance=None)[source]
 
Check if a and b are almost equal.

 

 
 

 

-exsqrt(a)[source]

+exsqrt(a)[source]
 
Returns the principal complex square root of a.

 
Explanation

 
The argument of the principal square root is always within
@@ -4362,67 +4362,67 @@ 
Gaussian domains
 

-from_sympy(expr)[source]

+from_sympy(expr)[source]
 
Convert SymPy’s number to dtype.

 

 
 

 

-gcd(a, b)[source]

+gcd(a, b)[source]
 
Returns GCD of a and b.

 

 
 

 

-get_exact()[source]

+get_exact()[source]
 
Returns an exact domain associated with self.

 

 
 

 

-get_ring()[source]

+get_ring()[source]
 
Returns a ring associated with self.

 

 
 

 

-is_negative(element)[source]

+is_negative(element)[source]
 
Returns False for any ComplexElement.

 

 
 

 

-is_nonnegative(element)[source]

+is_nonnegative(element)[source]
 
Returns False for any ComplexElement.

 

 
 

 

-is_nonpositive(element)[source]

+is_nonpositive(element)[source]
 
Returns False for any ComplexElement.

 

 
 

 

-is_positive(element)[source]

+is_positive(element)[source]
 
Returns False for any ComplexElement.

 

 
 

 

-is_square(a)[source]

+is_square(a)[source]
 
Returns True. Every complex number has a complex square root.

 

 
 

 

-lcm(a, b)[source]

+lcm(a, b)[source]
 
Returns LCM of a and b.

 

 
 

 

-to_sympy(element)[source]

+to_sympy(element)[source]
 
Convert element to SymPy number.

 

 
@@ -4441,161 +4441,161 @@ 
Gaussian domainsorder=None,

 

 
-)[source]
+)[source]
 
A class for representing multivariate polynomial rings.

 

 

-factorial(a)[source]

+factorial(a)[source]
 
Returns factorial of \(a\).

 

 
 

 

-from_AlgebraicField(a, K0)[source]

+from_AlgebraicField(a, K0)[source]
 
Convert an algebraic number to dtype.

 

 
 

 

-from_ComplexField(a, K0)[source]

+from_ComplexField(a, K0)[source]
 
Convert a mpmath \(mpf\) object to \(dtype\).

 

 
 

 

-from_FractionField(a, K0)[source]

+from_FractionField(a, K0)[source]
 
Convert a rational function to dtype.

 

 
 

 

-from_GaussianIntegerRing(a, K0)[source]

+from_GaussianIntegerRing(a, K0)[source]
 
Convert a \(GaussianInteger\) object to \(dtype\).

 

 
 

 

-from_GaussianRationalField(a, K0)[source]

+from_GaussianRationalField(a, K0)[source]
 
Convert a \(GaussianRational\) object to \(dtype\).

 

 
 

 

-from_GlobalPolynomialRing(a, K0)[source]

+from_GlobalPolynomialRing(a, K0)[source]
 
Convert from old poly ring to dtype.

 

 
 

 

-from_PolynomialRing(a, K0)[source]

+from_PolynomialRing(a, K0)[source]
 
Convert a polynomial to dtype.

 

 
 

 

-from_QQ(a, K0)[source]

+from_QQ(a, K0)[source]
 
Convert a Python \(Fraction\) object to \(dtype\).

 

 
 

 

-from_QQ_gmpy(a, K0)[source]

+from_QQ_gmpy(a, K0)[source]
 
Convert a GMPY \(mpq\) object to \(dtype\).

 

 
 

 

-from_QQ_python(a, K0)[source]

+from_QQ_python(a, K0)[source]
 
Convert a Python \(Fraction\) object to \(dtype\).

 

 
 

 

-from_RealField(a, K0)[source]

+from_RealField(a, K0)[source]
 
Convert a mpmath \(mpf\) object to \(dtype\).

 

 
 

 

-from_ZZ(a, K0)[source]

+from_ZZ(a, K0)[source]
 
Convert a Python \(int\) object to \(dtype\).

 

 
 

 

-from_ZZ_gmpy(a, K0)[source]

+from_ZZ_gmpy(a, K0)[source]
 
Convert a GMPY \(mpz\) object to \(dtype\).

 

 
 

 

-from_ZZ_python(a, K0)[source]

+from_ZZ_python(a, K0)[source]
 
Convert a Python \(int\) object to \(dtype\).

 

 
 

 

-from_sympy(a)[source]

+from_sympy(a)[source]
 
Convert SymPy’s expression to \(dtype\).

 

 
 

 

-gcd(a, b)[source]

+gcd(a, b)[source]
 
Returns GCD of \(a\) and \(b\).

 

 
 

 

-gcdex(a, b)[source]

+gcdex(a, b)[source]
 
Extended GCD of \(a\) and \(b\).

 

 
 

 

-get_field()[source]

+get_field()[source]
 
Returns a field associated with \(self\).

 

 
 

 

-is_negative(a)[source]

+is_negative(a)[source]
 
Returns True if \(LC(a)\) is negative.

 

 
 

 

-is_nonnegative(a)[source]

+is_nonnegative(a)[source]
 
Returns True if \(LC(a)\) is non-negative.

 

 
 

 

-is_nonpositive(a)[source]

+is_nonpositive(a)[source]
 
Returns True if \(LC(a)\) is non-positive.

 

 
 

 

-is_positive(a)[source]

+is_positive(a)[source]
 
Returns True if \(LC(a)\) is positive.

 

 
 

 

-is_unit(a)[source]

+is_unit(a)[source]
 
Returns True if a is a unit of self

 

 
 

 

-lcm(a, b)[source]

+lcm(a, b)[source]
 
Returns LCM of \(a\) and \(b\).

 

 
 

 

-to_sympy(a)[source]

+to_sympy(a)[source]
 
Convert \(a\) to a SymPy object.

 

 
@@ -4614,143 +4614,143 @@ 
Gaussian domainsorder=None,

 

 
-)[source]
+)[source]
 
A class for representing multivariate rational function fields.

 

 

-denom(a)[source]

+denom(a)[source]
 
Returns denominator of a.

 

 
 

 

-factorial(a)[source]

+factorial(a)[source]
 
Returns factorial of a.

 

 
 

 

-from_AlgebraicField(a, K0)[source]

+from_AlgebraicField(a, K0)[source]
 
Convert an algebraic number to dtype.

 

 
 

 

-from_ComplexField(a, K0)[source]

+from_ComplexField(a, K0)[source]
 
Convert a mpmath mpf object to dtype.

 

 
 

 

-from_FractionField(a, K0)[source]

+from_FractionField(a, K0)[source]
 
Convert a rational function to dtype.

 

 
 

 

-from_GaussianIntegerRing(a, K0)[source]

+from_GaussianIntegerRing(a, K0)[source]
 
Convert a GaussianInteger object to dtype.

 

 
 

 

-from_GaussianRationalField(a, K0)[source]

+from_GaussianRationalField(a, K0)[source]
 
Convert a GaussianRational object to dtype.

 

 
 

 

-from_PolynomialRing(a, K0)[source]

+from_PolynomialRing(a, K0)[source]
 
Convert a polynomial to dtype.

 

 
 

 

-from_QQ(a, K0)[source]

+from_QQ(a, K0)[source]
 
Convert a Python Fraction object to dtype.

 

 
 

 

-from_QQ_gmpy(a, K0)[source]

+from_QQ_gmpy(a, K0)[source]
 
Convert a GMPY mpq object to dtype.

 

 
 

 

-from_QQ_python(a, K0)[source]

+from_QQ_python(a, K0)[source]
 
Convert a Python Fraction object to dtype.

 

 
 

 

-from_RealField(a, K0)[source]

+from_RealField(a, K0)[source]
 
Convert a mpmath mpf object to dtype.

 

 
 

 

-from_ZZ(a, K0)[source]

+from_ZZ(a, K0)[source]
 
Convert a Python int object to dtype.

 

 
 

 

-from_ZZ_gmpy(a, K0)[source]

+from_ZZ_gmpy(a, K0)[source]
 
Convert a GMPY mpz object to dtype.

 

 
 

 

-from_ZZ_python(a, K0)[source]

+from_ZZ_python(a, K0)[source]
 
Convert a Python int object to dtype.

 

 
 

 

-from_sympy(a)[source]

+from_sympy(a)[source]
 
Convert SymPy’s expression to dtype.

 

 
 

 

-get_ring()[source]

+get_ring()[source]
 
Returns a field associated with self.

 

 
 

 

-is_negative(a)[source]

+is_negative(a)[source]
 
Returns True if LC(a) is negative.

 

 
 

 

-is_nonnegative(a)[source]

+is_nonnegative(a)[source]
 
Returns True if LC(a) is non-negative.

 

 
 

 

-is_nonpositive(a)[source]

+is_nonpositive(a)[source]
 
Returns True if LC(a) is non-positive.

 

 
 

 

-is_positive(a)[source]

+is_positive(a)[source]
 
Returns True if LC(a) is positive.

 

 
 

 

-numer(a)[source]

+numer(a)[source]
 
Returns numerator of a.

 

 
 

 

-to_sympy(a)[source]

+to_sympy(a)[source]
 
Convert a to a SymPy object.

 

 
@@ -4761,161 +4761,161 @@ 
Gaussian domains
EX

 

 

-class sympy.polys.domains.ExpressionDomain[source]

+class sympy.polys.domains.ExpressionDomain[source]
 
A class for arbitrary expressions.

 

 

-class Expression(ex)[source]

+class Expression(ex)[source]
 
An arbitrary expression.

 

 
 

 

-denom(a)[source]

+denom(a)[source]
 
Returns denominator of a.

 

 
 

 

-dtype[source]

+dtype[source]
 
alias of Expression

 

 
 

 

-from_AlgebraicField(a, K0)[source]

+from_AlgebraicField(a, K0)[source]
 
Convert an ANP object to dtype.

 

 
 

 

-from_ComplexField(a, K0)[source]

+from_ComplexField(a, K0)[source]
 
Convert a mpmath mpc object to dtype.

 

 
 

 

-from_ExpressionDomain(a, K0)[source]

+from_ExpressionDomain(a, K0)[source]
 
Convert a EX object to dtype.

 

 
 

 

-from_FractionField(a, K0)[source]

+from_FractionField(a, K0)[source]
 
Convert a DMF object to dtype.

 

 
 

 

-from_GaussianIntegerRing(a, K0)[source]

+from_GaussianIntegerRing(a, K0)[source]
 
Convert a GaussianRational object to dtype.

 

 
 

 

-from_GaussianRationalField(a, K0)[source]

+from_GaussianRationalField(a, K0)[source]
 
Convert a GaussianRational object to dtype.

 

 
 

 

-from_PolynomialRing(a, K0)[source]

+from_PolynomialRing(a, K0)[source]
 
Convert a DMP object to dtype.

 

 
 

 

-from_QQ(a, K0)[source]

+from_QQ(a, K0)[source]
 
Convert a Python Fraction object to dtype.

 

 
 

 

-from_QQ_gmpy(a, K0)[source]

+from_QQ_gmpy(a, K0)[source]
 
Convert a GMPY mpq object to dtype.

 

 
 

 

-from_QQ_python(a, K0)[source]

+from_QQ_python(a, K0)[source]
 
Convert a Python Fraction object to dtype.

 

 
 

 

-from_RealField(a, K0)[source]

+from_RealField(a, K0)[source]
 
Convert a mpmath mpf object to dtype.

 

 
 

 

-from_ZZ(a, K0)[source]

+from_ZZ(a, K0)[source]
 
Convert a Python int object to dtype.

 

 
 

 

-from_ZZ_gmpy(a, K0)[source]

+from_ZZ_gmpy(a, K0)[source]
 
Convert a GMPY mpz object to dtype.

 

 
 

 

-from_ZZ_python(a, K0)[source]

+from_ZZ_python(a, K0)[source]
 
Convert a Python int object to dtype.

 

 
 

 

-from_sympy(a)[source]

+from_sympy(a)[source]
 
Convert SymPy’s expression to dtype.

 

 
 

 

-get_field()[source]

+get_field()[source]
 
Returns a field associated with self.

 

 
 

 

-get_ring()[source]

+get_ring()[source]
 
Returns a ring associated with self.

 

 
 

 

-is_negative(a)[source]

+is_negative(a)[source]
 
Returns True if a is negative.

 

 
 

 

-is_nonnegative(a)[source]

+is_nonnegative(a)[source]
 
Returns True if a is non-negative.

 

 
 

 

-is_nonpositive(a)[source]

+is_nonpositive(a)[source]
 
Returns True if a is non-positive.

 

 
 

 

-is_positive(a)[source]

+is_positive(a)[source]
 
Returns True if a is positive.

 

 
 

 

-numer(a)[source]

+numer(a)[source]
 
Returns numerator of a.

 

 
 

 

-to_sympy(a)[source]

+to_sympy(a)[source]
 
Convert a to a SymPy object.

 

 
@@ -4923,7 +4923,7 @@ 
Gaussian domains
 

-class ExpressionDomain.Expression(ex)[source]

+class ExpressionDomain.Expression(ex)[source]
 
An arbitrary expression.

 

 
@@ -4932,7 +4932,7 @@ 
Gaussian domains

 

 

-class sympy.polys.domains.quotientring.QuotientRing(ring, ideal)[source]

+class sympy.polys.domains.quotientring.QuotientRing(ring, ideal)[source]
 
Class representing (commutative) quotient rings.

 
You should not usually instantiate this by hand, instead use the constructor
 from the base ring in the construction.

@@ -4965,7 +4965,7 @@ 
Sparse polynomials
 

-sympy.polys.rings.ring(symbols, domain, order=LexOrder())[source]

+sympy.polys.rings.ring(symbols, domain, order=LexOrder())[source]
 
Construct a polynomial ring returning (ring, x_1, ..., x_n).

 

 
Parameters:

@@ -4996,7 +4996,7 @@ 
Sparse polynomials
 

-sympy.polys.rings.xring(symbols, domain, order=LexOrder())[source]

+sympy.polys.rings.xring(symbols, domain, order=LexOrder())[source]
 
Construct a polynomial ring returning (ring, (x_1, ..., x_n)).

 

 
Parameters:

@@ -5027,7 +5027,7 @@ 
Sparse polynomials
 

-sympy.polys.rings.vring(symbols, domain, order=LexOrder())[source]

+sympy.polys.rings.vring(symbols, domain, order=LexOrder())[source]
 
Construct a polynomial ring and inject x_1, ..., x_n into the global namespace.

 

 
Parameters:

@@ -5057,7 +5057,7 @@ 
Sparse polynomials
 

-sympy.polys.rings.sring(exprs, *symbols, **options)[source]

+sympy.polys.rings.sring(exprs, *symbols, **options)[source]
 
Construct a ring deriving generators and domain from options and input expressions.

 

 
Parameters:

@@ -5084,11 +5084,11 @@ 
Sparse polynomials
 

-class sympy.polys.rings.PolyRing(symbols, domain, order=LexOrder())[source]

+class sympy.polys.rings.PolyRing(symbols, domain, order=LexOrder())[source]
 
Multivariate distributed polynomial ring.

 

 

-add(*objs)[source]

+add(*objs)[source]
 
Add a sequence of polynomials or containers of polynomials.

 
Examples

 
>>> from sympy.polys.rings import ring
@@ -5106,44 +5106,44 @@ 
Sparse polynomials
 

-add_gens(symbols)[source]

+add_gens(symbols)[source]
 
Add the elements of symbols as generators to self

 

 
 

 

-compose(other)[source]

+compose(other)[source]
 
Add the generators of other to self

 

 
 

 

-drop(*gens)[source]

+drop(*gens)[source]
 
Remove specified generators from this ring.

 

 
 

 

-drop_to_ground(*gens)[source]

+drop_to_ground(*gens)[source]
 
Remove specified generators from the ring and inject them into
 its domain.

 

 
 

 

-index(gen)[source]

+index(gen)[source]
 
Compute index of gen in self.gens.

 

 
 

 

-monomial_basis(i)[source]

+monomial_basis(i)[source]
 
Return the ith-basis element.

 

 
 

 

-mul(*objs)[source]

+mul(*objs)[source]
 
Multiply a sequence of polynomials or containers of polynomials.

 
Examples

 
>>> from sympy.polys.rings import ring
@@ -5161,7 +5161,7 @@ 
Sparse polynomials
 

-symmetric_poly(n)[source]

+symmetric_poly(n)[source]
 
Return the elementary symmetric polynomial of degree n over
 this ring’s generators.

 

@@ -5170,17 +5170,17 @@ 
Sparse polynomials
 

-class sympy.polys.rings.PolyElement[source]

+class sympy.polys.rings.PolyElement[source]
 
Element of multivariate distributed polynomial ring.

 

 

-almosteq(p2, tolerance=None)[source]

+almosteq(p2, tolerance=None)[source]
 
Approximate equality test for polynomials.

 

 
 

 

-cancel(g)[source]

+cancel(g)[source]
 
Cancel common factors in a rational function f/g.

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -5195,7 +5195,7 @@ 
Sparse polynomials
 

-coeff(element)[source]

+coeff(element)[source]
 
Returns the coefficient that stands next to the given monomial.

 

 
Parameters:

@@ -5223,7 +5223,7 @@ 
Sparse polynomials
 

-coeff_wrt(x, deg)[source]

+coeff_wrt(x, deg)[source]
 
Coefficient of self with respect to x**deg.

 
Treating self as a univariate polynomial in x this finds the
 coefficient of x**deg as a polynomial in the other generators.

@@ -5268,7 +5268,7 @@ 
Sparse polynomials
 

-coeffs(order=None)[source]

+coeffs(order=None)[source]
 
Ordered list of polynomial coefficients.

 

 
Parameters:

@@ -5295,19 +5295,19 @@ 
Sparse polynomials
 

-const()[source]

+const()[source]
 
Returns the constant coefficient.

 

 
 

 

-content()[source]

+content()[source]
 
Returns GCD of polynomial’s coefficients.

 

 
 

 

-copy()[source]

+copy()[source]
 
Return a copy of polynomial self.

 
Polynomials are mutable; if one is interested in preserving
 a polynomial, and one plans to use inplace operations, one
@@ -5334,21 +5334,21 @@ 
Sparse polynomials
 

-degree(x=None)[source]

+degree(x=None)[source]
 
The leading degree in x or the main variable.

 
Note that the degree of 0 is negative infinity (float('-inf'))

 

 
 

 

-degrees()[source]

+degrees()[source]
 
A tuple containing leading degrees in all variables.

 
Note that the degree of 0 is negative infinity (float('-inf'))

 

 
 

 

-diff(x)[source]

+diff(x)[source]
 
Computes partial derivative in x.

 
Examples

 
>>> from sympy.polys.rings import ring
@@ -5365,7 +5365,7 @@ 
Sparse polynomials
 

-div(fv)[source]

+div(fv)[source]
 
Division algorithm, see [CLO] p64.

 

 
fv array of polynomials
return qv, r such that
@@ -5395,7 +5395,7 @@ 
Sparse polynomials
 

-imul_num(c)[source]

+imul_num(c)[source]
 
multiply inplace the polynomial p by an element in the
 coefficient ring, provided p is not one of the generators;
 else multiply not inplace

@@ -5423,25 +5423,25 @@ 
Sparse polynomials
 

-itercoeffs()[source]

+itercoeffs()[source]
 
Iterator over coefficients of a polynomial.

 

 
 

 

-itermonoms()[source]

+itermonoms()[source]
 
Iterator over monomials of a polynomial.

 

 
 

 

-iterterms()[source]

+iterterms()[source]
 
Iterator over terms of a polynomial.

 

 
 

 

-leading_expv()[source]

+leading_expv()[source]
 
Leading monomial tuple according to the monomial ordering.

 
Examples

 
>>> from sympy.polys.rings import ring
@@ -5458,7 +5458,7 @@ 
Sparse polynomials
 

-leading_monom()[source]

+leading_monom()[source]
 
Leading monomial as a polynomial element.

 
Examples

 
>>> from sympy.polys.rings import ring
@@ -5474,7 +5474,7 @@ 
Sparse polynomials
 

-leading_term()[source]

+leading_term()[source]
 
Leading term as a polynomial element.

 
Examples

 
>>> from sympy.polys.rings import ring
@@ -5490,31 +5490,31 @@ 
Sparse polynomials
 

-listcoeffs()[source]

+listcoeffs()[source]
 
Unordered list of polynomial coefficients.

 

 
 

 

-listmonoms()[source]

+listmonoms()[source]
 
Unordered list of polynomial monomials.

 

 
 

 

-listterms()[source]

+listterms()[source]
 
Unordered list of polynomial terms.

 

 
 

 

-monic()[source]

+monic()[source]
 
Divides all coefficients by the leading coefficient.

 

 
 

 

-monoms(order=None)[source]

+monoms(order=None)[source]
 
Ordered list of polynomial monomials.

 

 
Parameters:

@@ -5541,7 +5541,7 @@ 
Sparse polynomials
 

-pdiv(g, x=None)[source]

+pdiv(g, x=None)[source]
 
Computes the pseudo-division of the polynomial self with respect to g.

 
The pseudo-division algorithm is used to find the pseudo-quotient q
 and pseudo-remainder r such that m*f = g*q + r, where m
@@ -5618,7 +5618,7 @@ 
Sparse polynomials
 

-pexquo(g, x=None)[source]

+pexquo(g, x=None)[source]
 
Polynomial exact pseudo-quotient in multivariate polynomial ring.

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -5648,7 +5648,7 @@ 
Sparse polynomials
 

-pquo(g, x=None)[source]

+pquo(g, x=None)[source]
 
Polynomial pseudo-quotient in multivariate polynomial ring.

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -5676,7 +5676,7 @@ 
Sparse polynomials
 

-prem(g, x=None)[source]

+prem(g, x=None)[source]
 
Pseudo-remainder of the polynomial self with respect to g.

 
The pseudo-quotient q and pseudo-remainder r with respect to
 z when dividing f by g satisfy m*f = g*q + r,
@@ -5729,13 +5729,13 @@ 
Sparse polynomials
 

-primitive()[source]

+primitive()[source]
 
Returns content and a primitive polynomial.

 

 
 

 

-square()[source]

+square()[source]
 
square of a polynomial

 
Examples

 
>>> from sympy.polys.rings import ring
@@ -5752,13 +5752,13 @@ 
Sparse polynomials
 

-strip_zero()[source]

+strip_zero()[source]
 
Eliminate monomials with zero coefficient.

 

 
 

 

-subresultants(g, x=None)[source]

+subresultants(g, x=None)[source]
 
Computes the subresultant PRS of two polynomials self and g.

 

 
Parameters:

@@ -5797,7 +5797,7 @@ 
Sparse polynomials
 

-symmetrize()[source]

+symmetrize()[source]
 
Rewrite self in terms of elementary symmetric polynomials.

 

 
Returns:

@@ -5855,21 +5855,21 @@ 
Sparse polynomials
 

-tail_degree(x=None)[source]

+tail_degree(x=None)[source]
 
The tail degree in x or the main variable.

 
Note that the degree of 0 is negative infinity (float('-inf'))

 

 
 

 

-tail_degrees()[source]

+tail_degrees()[source]
 
A tuple containing tail degrees in all variables.

 
Note that the degree of 0 is negative infinity (float('-inf'))

 

 
 

 

-terms(order=None)[source]

+terms(order=None)[source]
 
Ordered list of polynomial terms.

 

 
Parameters:

@@ -5902,25 +5902,25 @@ 
Sparse rational functions
 

-sympy.polys.fields.field(symbols, domain, order=LexOrder())[source]

+sympy.polys.fields.field(symbols, domain, order=LexOrder())[source]
 
Construct new rational function field returning (field, x1, …, xn).

 

 
 

 

-sympy.polys.fields.xfield(symbols, domain, order=LexOrder())[source]

+sympy.polys.fields.xfield(symbols, domain, order=LexOrder())[source]
 
Construct new rational function field returning (field, (x1, …, xn)).

 

 
 

 

-sympy.polys.fields.vfield(symbols, domain, order=LexOrder())[source]

+sympy.polys.fields.vfield(symbols, domain, order=LexOrder())[source]
 
Construct new rational function field and inject generators into global namespace.

 

 
 

 

-sympy.polys.fields.sfield(exprs, *symbols, **options)[source]

+sympy.polys.fields.sfield(exprs, *symbols, **options)[source]
 
Construct a field deriving generators and domain
 from options and input expressions.

 

@@ -5946,17 +5946,17 @@ 
Sparse rational functions
 

-class sympy.polys.fields.FracField(symbols, domain, order=LexOrder())[source]

+class sympy.polys.fields.FracField(symbols, domain, order=LexOrder())[source]
 
Multivariate distributed rational function field.

 

 
 

 

-class sympy.polys.fields.FracElement(numer, denom=None)[source]

+class sympy.polys.fields.FracElement(numer, denom=None)[source]
 
Element of multivariate distributed rational function field.

 

 

-diff(x)[source]

+diff(x)[source]
 
Computes partial derivative in x.

 
Examples

 
>>> from sympy.polys.fields import field
@@ -5977,179 +5977,179 @@ 
Sparse rational functions

 

 

-class sympy.polys.polyclasses.DMP(rep, dom, lev=None)[source]

+class sympy.polys.polyclasses.DMP(rep, dom, lev=None)[source]
 
Dense Multivariate Polynomials over \(K\).

 

 

-LC()[source]

+LC()[source]
 
Returns the leading coefficient of f.

 

 
 

 

-TC()[source]

+TC()[source]
 
Returns the trailing coefficient of f.

 

 
 

 

-abs()[source]

+abs()[source]
 
Make all coefficients in f positive.

 

 
 

 

-add(g)[source]

+add(g)[source]
 
Add two multivariate polynomials f and g.

 

 
 

 

-add_ground(c)[source]

+add_ground(c)[source]
 
Add an element of the ground domain to f.

 

 
 

 

-all_coeffs()[source]

+all_coeffs()[source]
 
Returns all coefficients from f.

 

 
 

 

-all_monoms()[source]

+all_monoms()[source]
 
Returns all monomials from f.

 

 
 

 

-all_terms()[source]

+all_terms()[source]
 
Returns all terms from a f.

 

 
 

 

-cancel(g, include=True)[source]

+cancel(g, include=True)[source]
 
Cancel common factors in a rational function f/g.

 

 
 

 

-cauchy_lower_bound()[source]

+cauchy_lower_bound()[source]
 
Computes the Cauchy lower bound on the nonzero roots of f.

 

 
 

 

-cauchy_upper_bound()[source]

+cauchy_upper_bound()[source]
 
Computes the Cauchy upper bound on the roots of f.

 

 
 

 

-clear_denoms()[source]

+clear_denoms()[source]
 
Clear denominators, but keep the ground domain.

 

 
 

 

-coeffs(order=None)[source]

+coeffs(order=None)[source]
 
Returns all non-zero coefficients from f in lex order.

 

 
 

 

-cofactors(g)[source]

+cofactors(g)[source]
 
Returns GCD of f and g and their cofactors.

 

 
 

 

-compose(g)[source]

+compose(g)[source]
 
Computes functional composition of f and g.

 

 
 

 

-content()[source]

+content()[source]
 
Returns GCD of polynomial coefficients.

 

 
 

 

-convert(dom)[source]

+convert(dom)[source]
 
Convert f to a DMP over the new domain.

 

 
 

 

-count_complex_roots(inf=None, sup=None)[source]

+count_complex_roots(inf=None, sup=None)[source]
 
Return the number of complex roots of f in [inf, sup].

 

 
 

 

-count_real_roots(inf=None, sup=None)[source]

+count_real_roots(inf=None, sup=None)[source]
 
Return the number of real roots of f in [inf, sup].

 

 
 

 

-decompose()[source]

+decompose()[source]
 
Computes functional decomposition of f.

 

 
 

 

-deflate()[source]

+deflate()[source]
 
Reduce degree of \(f\) by mapping \(x_i^m\) to \(y_i\).

 

 
 

 

-degree(j=0)[source]

+degree(j=0)[source]
 
Returns the leading degree of f in x_j.

 

 
 

 

-degree_list()[source]

+degree_list()[source]
 
Returns a list of degrees of f.

 

 
 

 

-diff(m=1, j=0)[source]

+diff(m=1, j=0)[source]
 
Computes the m-th order derivative of f in x_j.

 

 
 

 

-discriminant()[source]

+discriminant()[source]
 
Computes discriminant of f.

 

 
 

 

-div(g)[source]

+div(g)[source]
 
Polynomial division with remainder of f and g.

 

 
 

 

-eject(dom, front=False)[source]

+eject(dom, front=False)[source]
 
Eject selected generators into the ground domain.

 

 
 

 

-eval(a, j=0)[source]

+eval(a, j=0)[source]
 
Evaluates f at the given point a in x_j.

 

 
 

 

-exclude()[source]

+exclude()[source]
 
Remove useless generators from f.

 
Returns the removed generators and the new excluded f.

 
Examples

@@ -6165,91 +6165,91 @@ 
Dense polynomials
 

-exquo(g)[source]

+exquo(g)[source]
 
Computes polynomial exact quotient of f and g.

 

 
 

 

-exquo_ground(c)[source]

+exquo_ground(c)[source]
 
Exact quotient of f by a an element of the ground domain.

 

 
 

 

-factor_list()[source]

+factor_list()[source]
 
Returns a list of irreducible factors of f.

 

 
 

 

-factor_list_include()[source]

+factor_list_include()[source]
 
Returns a list of irreducible factors of f.

 

 
 

 

-classmethod from_list(rep, lev, dom)[source]

+classmethod from_list(rep, lev, dom)[source]
 
Create an instance of cls given a list of native coefficients.

 

 
 

 

-classmethod from_sympy_list(rep, lev, dom)[source]

+classmethod from_sympy_list(rep, lev, dom)[source]
 
Create an instance of cls given a list of SymPy coefficients.

 

 
 

 

-gcd(g)[source]

+gcd(g)[source]
 
Returns polynomial GCD of f and g.

 

 
 

 

-gcdex(g)[source]

+gcdex(g)[source]
 
Extended Euclidean algorithm, if univariate.

 

 
 

 

-gff_list()[source]

+gff_list()[source]
 
Computes greatest factorial factorization of f.

 

 
 

 

-ground_new(coeff)[source]

+ground_new(coeff)[source]
 
Construct a new ground instance of f.

 

 
 

 

-half_gcdex(g)[source]

+half_gcdex(g)[source]
 
Half extended Euclidean algorithm, if univariate.

 

 
 

 

-homogeneous_order()[source]

+homogeneous_order()[source]
 
Returns the homogeneous order of f.

 

 
 

 

-homogenize(s)[source]

+homogenize(s)[source]
 
Return homogeneous polynomial of f

 

 
 

 

-inject(front=False)[source]

+inject(front=False)[source]
 
Inject ground domain generators into f.

 

 
 

 

-integrate(m=1, j=0)[source]

+integrate(m=1, j=0)[source]
 
Computes the m-th order indefinite integral of f in x_j.

 

 
@@ -6266,13 +6266,13 @@ 
Dense polynomialssqf=False,

 

 
-)[source]
+)[source]
 
Compute isolating intervals for roots of f.

 

 
 

 

-invert(g)[source]

+invert(g)[source]
 
Invert f modulo g, if possible.

 

 
@@ -6350,91 +6350,91 @@ 
Dense polynomials
 

-l1_norm()[source]

+l1_norm()[source]
 
Returns l1 norm of f.

 

 
 

 

-l2_norm_squared()[source]

+l2_norm_squared()[source]
 
Return squared l2 norm of f.

 

 
 

 

-lcm(g)[source]

+lcm(g)[source]
 
Returns polynomial LCM of f and g.

 

 
 

 

-lift()[source]

+lift()[source]
 
Convert algebraic coefficients to rationals.

 

 
 

 

-max_norm()[source]

+max_norm()[source]
 
Returns maximum norm of f.

 

 
 

 

-mignotte_sep_bound_squared()[source]

+mignotte_sep_bound_squared()[source]
 
Computes the squared Mignotte bound on root separations of f.

 

 
 

 

-monic()[source]

+monic()[source]
 
Divides all coefficients by LC(f).

 

 
 

 

-monoms(order=None)[source]

+monoms(order=None)[source]
 
Returns all non-zero monomials from f in lex order.

 

 
 

 

-mul(g)[source]

+mul(g)[source]
 
Multiply two multivariate polynomials f and g.

 

 
 

 

-mul_ground(c)[source]

+mul_ground(c)[source]
 
Multiply f by a an element of the ground domain.

 

 
 

 

-neg()[source]

+neg()[source]
 
Negate all coefficients in f.

 

 
 

 

-norm()[source]

+norm()[source]
 
Computes Norm(f).

 

 
 

 

-nth(*N)[source]

+nth(*N)[source]
 
Returns the n-th coefficient of f.

 

 
 

 

-pdiv(g)[source]

+pdiv(g)[source]
 
Polynomial pseudo-division of f and g.

 

 
 

 

-permute(P)[source]

+permute(P)[source]
 
Returns a polynomial in \(K[x_{P(1)}, ..., x_{P(n)}]\).

 
Examples

 
>>> from sympy.polys.polyclasses import DMP
@@ -6453,43 +6453,43 @@ 
Dense polynomials
 

-pexquo(g)[source]

+pexquo(g)[source]
 
Polynomial exact pseudo-quotient of f and g.

 

 
 

 

-pow(n)[source]

+pow(n)[source]
 
Raise f to a non-negative power n.

 

 
 

 

-pquo(g)[source]

+pquo(g)[source]
 
Polynomial pseudo-quotient of f and g.

 

 
 

 

-prem(g)[source]

+prem(g)[source]
 
Polynomial pseudo-remainder of f and g.

 

 
 

 

-primitive()[source]

+primitive()[source]
 
Returns content and a primitive form of f.

 

 
 

 

-quo(g)[source]

+quo(g)[source]
 
Computes polynomial quotient of f and g.

 

 
 

 

-quo_ground(c)[source]

+quo_ground(c)[source]
 
Quotient of f by a an element of the ground domain.

 

 
@@ -6505,14 +6505,14 @@ 
Dense polynomialsfast=False,

 

 
-)[source]
+)[source]
 
Refine an isolating interval to the given precision.

 
eps should be a rational number.

 

 
 

 

-rem(g)[source]

+rem(g)[source]
 
Computes polynomial remainder of f and g.

 

 
@@ -6524,103 +6524,103 @@ 
Dense polynomials
 

-resultant(g, includePRS=False)[source]

+resultant(g, includePRS=False)[source]
 
Computes resultant of f and g via PRS.

 

 
 

 

-revert(n)[source]

+revert(n)[source]
 
Compute f**(-1) mod x**n.

 

 
 

 

-shift(a)[source]

+shift(a)[source]
 
Efficiently compute Taylor shift f(x + a).

 

 
 

 

-shift_list(a)[source]

+shift_list(a)[source]
 
Efficiently compute Taylor shift f(X + A).

 

 
 

 

-slice(m, n, j=0)[source]

+slice(m, n, j=0)[source]
 
Take a continuous subsequence of terms of f.

 

 
 

 

-sqf_list(all=False)[source]

+sqf_list(all=False)[source]
 
Returns a list of square-free factors of f.

 

 
 

 

-sqf_list_include(all=False)[source]

+sqf_list_include(all=False)[source]
 
Returns a list of square-free factors of f.

 

 
 

 

-sqf_norm()[source]

+sqf_norm()[source]
 
Computes square-free norm of f.

 

 
 

 

-sqf_part()[source]

+sqf_part()[source]
 
Computes square-free part of f.

 

 
 

 

-sqr()[source]

+sqr()[source]
 
Square a multivariate polynomial f.

 

 
 

 

-sturm()[source]

+sturm()[source]
 
Computes the Sturm sequence of f.

 

 
 

 

-sub(g)[source]

+sub(g)[source]
 
Subtract two multivariate polynomials f and g.

 

 
 

 

-sub_ground(c)[source]

+sub_ground(c)[source]
 
Subtract an element of the ground domain from f.

 

 
 

 

-subresultants(g)[source]

+subresultants(g)[source]
 
Computes subresultant PRS sequence of f and g.

 

 
 

 

-terms(order=None)[source]

+terms(order=None)[source]
 
Returns all non-zero terms from f in lex order.

 

 
 

 

-terms_gcd()[source]

+terms_gcd()[source]
 
Remove GCD of terms from the polynomial f.

 

 
 

 

-to_best()[source]

+to_best()[source]
 
Convert to DUP_Flint if possible.

 
This method should be used when the domain or level is changed and it
 potentially becomes possible to convert from DMP_Python to DUP_Flint.

@@ -6628,74 +6628,74 @@ 
Dense polynomials
 

-to_dict(zero=False)[source]

+to_dict(zero=False)[source]
 
Convert f to a dict representation with native coefficients.

 

 
 

 

-to_exact()[source]

+to_exact()[source]
 
Make the ground domain exact.

 

 
 

 

-to_field()[source]

+to_field()[source]
 
Make the ground domain a field.

 

 
 

 

-to_list()[source]

+to_list()[source]
 
Convert f to a list representation with native coefficients.

 

 
 

 

-to_ring()[source]

+to_ring()[source]
 
Make the ground domain a ring.

 

 
 

 

-to_sympy_dict(zero=False)[source]

+to_sympy_dict(zero=False)[source]
 
Convert f to a dict representation with SymPy coefficients.

 

 
 

 

-to_sympy_list()[source]

+to_sympy_list()[source]
 
Convert f to a list representation with SymPy coefficients.

 

 
 

 

-to_tuple()[source]

+to_tuple()[source]
 
Convert f to a tuple representation with native coefficients.

 
This is needed for hashing.

 

 
 

 

-total_degree()[source]

+total_degree()[source]
 
Returns the total degree of f.

 

 
 

 

-transform(p, q)[source]

+transform(p, q)[source]
 
Evaluate functional transformation q**n * f(p/q).

 

 
 

 

-trunc(p)[source]

+trunc(p)[source]
 
Reduce f modulo a constant p.

 

 
 

 

-unify_DMP(g)[source]

+unify_DMP(g)[source]
 
Unify and return DMP instances of f and g.

 

 
@@ -6703,53 +6703,53 @@ 
Dense polynomials
 

-class sympy.polys.polyclasses.DMF(rep, dom, lev=None)[source]

+class sympy.polys.polyclasses.DMF(rep, dom, lev=None)[source]
 
Dense Multivariate Fractions over \(K\).

 

 

-add(g)[source]

+add(g)[source]
 
Add two multivariate fractions f and g.

 

 
 

 

-add_ground(c)[source]

+add_ground(c)[source]
 
Add an element of the ground domain to f.

 

 
 

 

-cancel()[source]

+cancel()[source]
 
Remove common factors from f.num and f.den.

 

 
 

 

-denom()[source]

+denom()[source]
 
Returns the denominator of f.

 

 
 

 

-exquo(g)[source]

+exquo(g)[source]
 
Computes quotient of fractions f and g.

 

 
 

 

-frac_unify(g)[source]

+frac_unify(g)[source]
 
Unify representations of two multivariate fractions.

 

 
 

 

-half_per(rep, kill=False)[source]

+half_per(rep, kill=False)[source]
 
Create a DMP out of the given representation.

 

 
 

 

-invert(check=True)[source]

+invert(check=True)[source]
 
Computes inverse of a fraction f.

 

 
@@ -6767,49 +6767,49 @@ 
Dense polynomials
 

-mul(g)[source]

+mul(g)[source]
 
Multiply two multivariate fractions f and g.

 

 
 

 

-neg()[source]

+neg()[source]
 
Negate all coefficients in f.

 

 
 

 

-numer()[source]

+numer()[source]
 
Returns the numerator of f.

 

 
 

 

-per(num, den, cancel=True, kill=False)[source]

+per(num, den, cancel=True, kill=False)[source]
 
Create a DMF out of the given representation.

 

 
 

 

-poly_unify(g)[source]

+poly_unify(g)[source]
 
Unify a multivariate fraction and a polynomial.

 

 
 

 

-pow(n)[source]

+pow(n)[source]
 
Raise f to a non-negative power n.

 

 
 

 

-quo(g)[source]

+quo(g)[source]
 
Computes quotient of fractions f and g.

 

 
 

 

-sub(g)[source]

+sub(g)[source]
 
Subtract two multivariate fractions f and g.

 

 
@@ -6817,29 +6817,29 @@ 
Dense polynomials
 

-class sympy.polys.polyclasses.ANP(rep, mod, dom)[source]

+class sympy.polys.polyclasses.ANP(rep, mod, dom)[source]
 
Dense Algebraic Number Polynomials over a field.

 

 

-LC()[source]

+LC()[source]
 
Returns the leading coefficient of f.

 

 
 

 

-TC()[source]

+TC()[source]
 
Returns the trailing coefficient of f.

 

 
 

 

-add_ground(c)[source]

+add_ground(c)[source]
 
Add an element of the ground domain to f.

 

 
 

 

-convert(dom)[source]

+convert(dom)[source]
 
Convert f to a ANP over a new domain.

 

 
@@ -6863,74 +6863,74 @@ 
Dense polynomials
 

-mod_to_list()[source]

+mod_to_list()[source]
 
Return f.mod as a list with native coefficients.

 

 
 

 

-mul_ground(c)[source]

+mul_ground(c)[source]
 
Multiply f by an element of the ground domain.

 

 
 

 

-pow(n)[source]

+pow(n)[source]
 
Raise f to a non-negative power n.

 

 
 

 

-quo_ground(c)[source]

+quo_ground(c)[source]
 
Quotient of f by an element of the ground domain.

 

 
 

 

-sub_ground(c)[source]

+sub_ground(c)[source]
 
Subtract an element of the ground domain from f.

 

 
 

 

-to_dict()[source]

+to_dict()[source]
 
Convert f to a dict representation with native coefficients.

 

 
 

 

-to_list()[source]

+to_list()[source]
 
Convert f to a list representation with native coefficients.

 

 
 

 

-to_sympy_dict()[source]

+to_sympy_dict()[source]
 
Convert f to a dict representation with SymPy coefficients.

 

 
 

 

-to_sympy_list()[source]

+to_sympy_list()[source]
 
Convert f to a list representation with SymPy coefficients.

 

 
 

 

-to_tuple()[source]

+to_tuple()[source]
 
Convert f to a tuple representation with native coefficients.

 
This is needed for hashing.

 

 
 

 

-unify(g)[source]

+unify(g)[source]
 
Unify representations of two algebraic numbers.

 

 
 

 

-unify_ANP(g)[source]

+unify_ANP(g)[source]
 
Unify and return DMP instances of f and g.

 

 
diff --git a/dev/modules/polys/internals.html b/dev/modules/polys/internals.html
index b110adbd856..4fd202d10b7 100644
--- a/dev/modules/polys/internals.html
+++ b/dev/modules/polys/internals.html
@@ -850,7 +850,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_LC(f, K)[source]

+sympy.polys.densebasic.dmp_LC(f, K)[source]
 
Return leading coefficient of f.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -867,7 +867,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_TC(f, K)[source]

+sympy.polys.densebasic.dmp_TC(f, K)[source]
 
Return trailing coefficient of f.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -884,7 +884,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_ground_LC(f, u, K)[source]

+sympy.polys.densebasic.dmp_ground_LC(f, u, K)[source]
 
Return the ground leading coefficient.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -902,7 +902,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_ground_TC(f, u, K)[source]

+sympy.polys.densebasic.dmp_ground_TC(f, u, K)[source]
 
Return the ground trailing coefficient.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -920,7 +920,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_true_LT(f, u, K)[source]

+sympy.polys.densebasic.dmp_true_LT(f, u, K)[source]
 
Return the leading term c * x_1**n_1 ... x_k**n_k.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -938,7 +938,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_degree(f, u)[source]

+sympy.polys.densebasic.dmp_degree(f, u)[source]
 
Return the leading degree of f in x_0 in K[X].

 
Note that the degree of 0 is negative infinity (float('-inf')).

 
Examples

@@ -961,7 +961,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_degree_in(f, j, u)[source]

+sympy.polys.densebasic.dmp_degree_in(f, j, u)[source]
 
Return the leading degree of f in x_j in K[X].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -981,7 +981,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_degree_list(f, u)[source]

+sympy.polys.densebasic.dmp_degree_list(f, u)[source]
 
Return a list of degrees of f in K[X].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -999,7 +999,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_strip(f, u)[source]

+sympy.polys.densebasic.dmp_strip(f, u)[source]
 
Remove leading zeros from f in K[X].

 
Examples

 
>>> from sympy.polys.densebasic import dmp_strip
@@ -1013,7 +1013,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_validate(f, K=None)[source]

+sympy.polys.densebasic.dmp_validate(f, K=None)[source]
 
Return the number of levels in f and recursively strip it.

 
Examples

 
>>> from sympy.polys.densebasic import dmp_validate
@@ -1033,7 +1033,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dup_reverse(f)[source]

+sympy.polys.densebasic.dup_reverse(f)[source]
 
Compute x**n * f(1/x), i.e.: reverse f in K[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1051,7 +1051,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_copy(f, u)[source]

+sympy.polys.densebasic.dmp_copy(f, u)[source]
 
Create a new copy of a polynomial f in K[X].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1069,7 +1069,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_to_tuple(f, u)[source]

+sympy.polys.densebasic.dmp_to_tuple(f, u)[source]
 
Convert \(f\) into a nested tuple of tuples.

 
This is needed for hashing.  This is similar to dmp_copy().

 
Examples

@@ -1088,7 +1088,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_normal(f, u, K)[source]

+sympy.polys.densebasic.dmp_normal(f, u, K)[source]
 
Normalize a multivariate polynomial in the given domain.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1103,7 +1103,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_convert(f, u, K0, K1)[source]

+sympy.polys.densebasic.dmp_convert(f, u, K0, K1)[source]
 
Convert the ground domain of f from K0 to K1.

 
Examples

 
>>> from sympy.polys.rings import ring
@@ -1124,7 +1124,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_from_sympy(f, u, K)[source]

+sympy.polys.densebasic.dmp_from_sympy(f, u, K)[source]
 
Convert the ground domain of f from SymPy to K.

 
Examples

 
>>> from sympy import S
@@ -1140,7 +1140,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_nth(f, n, u, K)[source]

+sympy.polys.densebasic.dmp_nth(f, n, u, K)[source]
 
Return the n-th coefficient of f in K[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1160,7 +1160,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_ground_nth(f, N, u, K)[source]

+sympy.polys.densebasic.dmp_ground_nth(f, N, u, K)[source]
 
Return the ground n-th coefficient of f in K[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1178,7 +1178,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_zero_p(f, u)[source]

+sympy.polys.densebasic.dmp_zero_p(f, u)[source]
 
Return True if f is zero in K[X].

 
Examples

 
>>> from sympy.polys.densebasic import dmp_zero_p
@@ -1194,7 +1194,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_zero(u)[source]

+sympy.polys.densebasic.dmp_zero(u)[source]
 
Return a multivariate zero.

 
Examples

 
>>> from sympy.polys.densebasic import dmp_zero
@@ -1208,7 +1208,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_one_p(f, u, K)[source]

+sympy.polys.densebasic.dmp_one_p(f, u, K)[source]
 
Return True if f is one in K[X].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1223,7 +1223,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_one(u, K)[source]

+sympy.polys.densebasic.dmp_one(u, K)[source]
 
Return a multivariate one over K.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1238,7 +1238,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_ground_p(f, c, u)[source]

+sympy.polys.densebasic.dmp_ground_p(f, c, u)[source]
 
Return True if f is constant in K[X].

 
Examples

 
>>> from sympy.polys.densebasic import dmp_ground_p
@@ -1254,7 +1254,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_ground(c, u)[source]

+sympy.polys.densebasic.dmp_ground(c, u)[source]
 
Return a multivariate constant.

 
Examples

 
>>> from sympy.polys.densebasic import dmp_ground
@@ -1270,7 +1270,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_zeros(n, u, K)[source]

+sympy.polys.densebasic.dmp_zeros(n, u, K)[source]
 
Return a list of multivariate zeros.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1287,7 +1287,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_grounds(c, n, u)[source]

+sympy.polys.densebasic.dmp_grounds(c, n, u)[source]
 
Return a list of multivariate constants.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1304,7 +1304,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_negative_p(f, u, K)[source]

+sympy.polys.densebasic.dmp_negative_p(f, u, K)[source]
 
Return True if LC(f) is negative.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1321,7 +1321,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_positive_p(f, u, K)[source]

+sympy.polys.densebasic.dmp_positive_p(f, u, K)[source]
 
Return True if LC(f) is positive.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1338,7 +1338,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_from_dict(f, u, K)[source]

+sympy.polys.densebasic.dmp_from_dict(f, u, K)[source]
 
Create a K[X] polynomial from a dict.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1355,7 +1355,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_to_dict(f, u, K=None, zero=False)[source]

+sympy.polys.densebasic.dmp_to_dict(f, u, K=None, zero=False)[source]
 
Convert a K[X] polynomial to a dict``.

 
Examples

 
>>> from sympy.polys.densebasic import dmp_to_dict
@@ -1371,7 +1371,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_swap(f, i, j, u, K)[source]

+sympy.polys.densebasic.dmp_swap(f, i, j, u, K)[source]
 
Transform K[..x_i..x_j..] to K[..x_j..x_i..].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1393,7 +1393,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_permute(f, P, u, K)[source]

+sympy.polys.densebasic.dmp_permute(f, P, u, K)[source]
 
Return a polynomial in K[x_{P(1)},..,x_{P(n)}].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1413,7 +1413,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_nest(f, l, K)[source]

+sympy.polys.densebasic.dmp_nest(f, l, K)[source]
 
Return a multivariate value nested l-levels.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1428,7 +1428,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_raise(f, l, u, K)[source]

+sympy.polys.densebasic.dmp_raise(f, l, u, K)[source]
 
Return a multivariate polynomial raised l-levels.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1446,7 +1446,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_deflate(f, u, K)[source]

+sympy.polys.densebasic.dmp_deflate(f, u, K)[source]
 
Map x_i**m_i to y_i in a polynomial in K[X].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1464,7 +1464,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_multi_deflate(polys, u, K)[source]

+sympy.polys.densebasic.dmp_multi_deflate(polys, u, K)[source]
 
Map x_i**m_i to y_i in a set of polynomials in K[X].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1483,7 +1483,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_inflate(f, M, u, K)[source]

+sympy.polys.densebasic.dmp_inflate(f, M, u, K)[source]
 
Map y_i to x_i**k_i in a polynomial in K[X].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1501,7 +1501,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_exclude(f, u, K)[source]

+sympy.polys.densebasic.dmp_exclude(f, u, K)[source]
 
Exclude useless levels from f.

 
Return the levels excluded, the new excluded f, and the new u.

 
Examples

@@ -1520,7 +1520,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_include(f, J, u, K)[source]

+sympy.polys.densebasic.dmp_include(f, J, u, K)[source]
 
Include useless levels in f.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1538,7 +1538,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_inject(f, u, K, front=False)[source]

+sympy.polys.densebasic.dmp_inject(f, u, K, front=False)[source]
 
Convert f from K[X][Y] to K[X,Y].

 
Examples

 
>>> from sympy.polys.rings import ring
@@ -1559,7 +1559,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_eject(f, u, K, front=False)[source]

+sympy.polys.densebasic.dmp_eject(f, u, K, front=False)[source]
 
Convert f from K[X,Y] to K[X][Y].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1574,7 +1574,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_terms_gcd(f, u, K)[source]

+sympy.polys.densebasic.dmp_terms_gcd(f, u, K)[source]
 
Remove GCD of terms from f in K[X].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1592,7 +1592,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_list_terms(f, u, K, order=None)[source]

+sympy.polys.densebasic.dmp_list_terms(f, u, K, order=None)[source]
 
List all non-zero terms from f in the given order order.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1612,7 +1612,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_apply_pairs(f, g, h, args, u, K)[source]

+sympy.polys.densebasic.dmp_apply_pairs(f, g, h, args, u, K)[source]
 
Apply h to pairs of coefficients of f and g.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1630,13 +1630,13 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densebasic.dmp_slice(f, m, n, u, K)[source]

+sympy.polys.densebasic.dmp_slice(f, m, n, u, K)[source]
 
Take a continuous subsequence of terms of f in K[X].

 

 
 

 

-sympy.polys.densebasic.dup_random(n, a, b, K)[source]

+sympy.polys.densebasic.dup_random(n, a, b, K)[source]
 
Return a polynomial of degree n with coefficients in [a, b].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -1652,7 +1652,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_add_term(f, c, i, u, K)[source]

+sympy.polys.densearith.dmp_add_term(f, c, i, u, K)[source]
 
Add c(x_2..x_u)*x_0**i to f in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1667,7 +1667,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_sub_term(f, c, i, u, K)[source]

+sympy.polys.densearith.dmp_sub_term(f, c, i, u, K)[source]
 
Subtract c(x_2..x_u)*x_0**i from f in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1682,7 +1682,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_mul_term(f, c, i, u, K)[source]

+sympy.polys.densearith.dmp_mul_term(f, c, i, u, K)[source]
 
Multiply f by c(x_2..x_u)*x_0**i in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1697,7 +1697,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_add_ground(f, c, u, K)[source]

+sympy.polys.densearith.dmp_add_ground(f, c, u, K)[source]
 
Add an element of the ground domain to f.

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1712,7 +1712,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_sub_ground(f, c, u, K)[source]

+sympy.polys.densearith.dmp_sub_ground(f, c, u, K)[source]
 
Subtract an element of the ground domain from f.

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1727,7 +1727,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_mul_ground(f, c, u, K)[source]

+sympy.polys.densearith.dmp_mul_ground(f, c, u, K)[source]
 
Multiply f by a constant value in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1742,7 +1742,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_quo_ground(f, c, u, K)[source]

+sympy.polys.densearith.dmp_quo_ground(f, c, u, K)[source]
 
Quotient by a constant in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ, QQ
@@ -1762,7 +1762,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_exquo_ground(f, c, u, K)[source]

+sympy.polys.densearith.dmp_exquo_ground(f, c, u, K)[source]
 
Exact quotient by a constant in K[X].

 
Examples

 
>>> from sympy.polys import ring, QQ
@@ -1777,7 +1777,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dup_lshift(f, n, K)[source]

+sympy.polys.densearith.dup_lshift(f, n, K)[source]
 
Efficiently multiply f by x**n in K[x].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1792,7 +1792,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dup_rshift(f, n, K)[source]

+sympy.polys.densearith.dup_rshift(f, n, K)[source]
 
Efficiently divide f by x**n in K[x].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1809,7 +1809,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_abs(f, u, K)[source]

+sympy.polys.densearith.dmp_abs(f, u, K)[source]
 
Make all coefficients positive in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1824,7 +1824,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_neg(f, u, K)[source]

+sympy.polys.densearith.dmp_neg(f, u, K)[source]
 
Negate a polynomial in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1839,7 +1839,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_add(f, g, u, K)[source]

+sympy.polys.densearith.dmp_add(f, g, u, K)[source]
 
Add dense polynomials in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1854,7 +1854,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_sub(f, g, u, K)[source]

+sympy.polys.densearith.dmp_sub(f, g, u, K)[source]
 
Subtract dense polynomials in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1869,7 +1869,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_add_mul(f, g, h, u, K)[source]

+sympy.polys.densearith.dmp_add_mul(f, g, h, u, K)[source]
 
Returns f + g*h where f, g, h are in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1884,7 +1884,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_sub_mul(f, g, h, u, K)[source]

+sympy.polys.densearith.dmp_sub_mul(f, g, h, u, K)[source]
 
Returns f - g*h where f, g, h are in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1899,7 +1899,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_mul(f, g, u, K)[source]

+sympy.polys.densearith.dmp_mul(f, g, u, K)[source]
 
Multiply dense polynomials in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1914,7 +1914,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_sqr(f, u, K)[source]

+sympy.polys.densearith.dmp_sqr(f, u, K)[source]
 
Square dense polynomials in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1929,7 +1929,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_pow(f, n, u, K)[source]

+sympy.polys.densearith.dmp_pow(f, n, u, K)[source]
 
Raise f to the n-th power in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1944,7 +1944,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_pdiv(f, g, u, K)[source]

+sympy.polys.densearith.dmp_pdiv(f, g, u, K)[source]
 
Polynomial pseudo-division in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1959,7 +1959,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_prem(f, g, u, K)[source]

+sympy.polys.densearith.dmp_prem(f, g, u, K)[source]
 
Polynomial pseudo-remainder in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1974,7 +1974,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_pquo(f, g, u, K)[source]

+sympy.polys.densearith.dmp_pquo(f, g, u, K)[source]
 
Polynomial exact pseudo-quotient in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -1998,7 +1998,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_pexquo(f, g, u, K)[source]

+sympy.polys.densearith.dmp_pexquo(f, g, u, K)[source]
 
Polynomial pseudo-quotient in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2024,7 +2024,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_rr_div(f, g, u, K)[source]

+sympy.polys.densearith.dmp_rr_div(f, g, u, K)[source]
 
Multivariate division with remainder over a ring.

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2039,7 +2039,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_ff_div(f, g, u, K)[source]

+sympy.polys.densearith.dmp_ff_div(f, g, u, K)[source]
 
Polynomial division with remainder over a field.

 
Examples

 
>>> from sympy.polys import ring, QQ
@@ -2054,7 +2054,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_div(f, g, u, K)[source]

+sympy.polys.densearith.dmp_div(f, g, u, K)[source]
 
Polynomial division with remainder in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ, QQ
@@ -2074,7 +2074,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_rem(f, g, u, K)[source]

+sympy.polys.densearith.dmp_rem(f, g, u, K)[source]
 
Returns polynomial remainder in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ, QQ
@@ -2094,7 +2094,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_quo(f, g, u, K)[source]

+sympy.polys.densearith.dmp_quo(f, g, u, K)[source]
 
Returns exact polynomial quotient in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ, QQ
@@ -2114,7 +2114,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_exquo(f, g, u, K)[source]

+sympy.polys.densearith.dmp_exquo(f, g, u, K)[source]
 
Returns polynomial quotient in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2140,7 +2140,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_max_norm(f, u, K)[source]

+sympy.polys.densearith.dmp_max_norm(f, u, K)[source]
 
Returns maximum norm of a polynomial in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2155,7 +2155,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_l1_norm(f, u, K)[source]

+sympy.polys.densearith.dmp_l1_norm(f, u, K)[source]
 
Returns l1 norm of a polynomial in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2170,7 +2170,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densearith.dmp_expand(polys, u, K)[source]

+sympy.polys.densearith.dmp_expand(polys, u, K)[source]
 
Multiply together several polynomials in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2186,7 +2186,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dmp_integrate(f, m, u, K)[source]

+sympy.polys.densetools.dmp_integrate(f, m, u, K)[source]
 
Computes the indefinite integral of f in x_0 in K[X].

 
Examples

 
>>> from sympy.polys import ring, QQ
@@ -2203,7 +2203,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dmp_integrate_in(f, m, j, u, K)[source]

+sympy.polys.densetools.dmp_integrate_in(f, m, j, u, K)[source]
 
Computes the indefinite integral of f in x_j in K[X].

 
Examples

 
>>> from sympy.polys import ring, QQ
@@ -2220,7 +2220,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dmp_diff(f, m, u, K)[source]

+sympy.polys.densetools.dmp_diff(f, m, u, K)[source]
 
m-th order derivative in x_0 of a polynomial in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2240,7 +2240,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dmp_diff_in(f, m, j, u, K)[source]

+sympy.polys.densetools.dmp_diff_in(f, m, j, u, K)[source]
 
m-th order derivative in x_j of a polynomial in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2260,7 +2260,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dmp_eval(f, a, u, K)[source]

+sympy.polys.densetools.dmp_eval(f, a, u, K)[source]
 
Evaluate a polynomial at x_0 = a in K[X] using the Horner scheme.

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2275,7 +2275,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dmp_eval_in(f, a, j, u, K)[source]

+sympy.polys.densetools.dmp_eval_in(f, a, j, u, K)[source]
 
Evaluate a polynomial at x_j = a in K[X] using the Horner scheme.

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2295,7 +2295,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dmp_eval_tail(f, A, u, K)[source]

+sympy.polys.densetools.dmp_eval_tail(f, A, u, K)[source]
 
Evaluate a polynomial at x_j = a_j, ... in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2315,7 +2315,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dmp_diff_eval_in(f, m, a, j, u, K)[source]

+sympy.polys.densetools.dmp_diff_eval_in(f, m, a, j, u, K)[source]
 
Differentiate and evaluate a polynomial in x_j at a in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2335,7 +2335,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dmp_trunc(f, p, u, K)[source]

+sympy.polys.densetools.dmp_trunc(f, p, u, K)[source]
 
Reduce a K[X] polynomial modulo a polynomial p in K[Y].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2354,7 +2354,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dmp_ground_trunc(f, p, u, K)[source]

+sympy.polys.densetools.dmp_ground_trunc(f, p, u, K)[source]
 
Reduce a K[X] polynomial modulo a constant p in K.

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2372,7 +2372,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dup_monic(f, K)[source]

+sympy.polys.densetools.dup_monic(f, K)[source]
 
Divide all coefficients by LC(f) in K[x].

 
Examples

 
>>> from sympy.polys import ring, ZZ, QQ
@@ -2392,7 +2392,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dmp_ground_monic(f, u, K)[source]

+sympy.polys.densetools.dmp_ground_monic(f, u, K)[source]
 
Divide all coefficients by LC(f) in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ, QQ
@@ -2418,7 +2418,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dup_content(f, K)[source]

+sympy.polys.densetools.dup_content(f, K)[source]
 
Compute the GCD of coefficients of f in K[x].

 
Examples

 
>>> from sympy.polys import ring, ZZ, QQ
@@ -2444,7 +2444,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dmp_ground_content(f, u, K)[source]

+sympy.polys.densetools.dmp_ground_content(f, u, K)[source]
 
Compute the GCD of coefficients of f in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ, QQ
@@ -2470,7 +2470,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dup_primitive(f, K)[source]

+sympy.polys.densetools.dup_primitive(f, K)[source]
 
Compute content and the primitive form of f in K[x].

 
Examples

 
>>> from sympy.polys import ring, ZZ, QQ
@@ -2496,7 +2496,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dmp_ground_primitive(f, u, K)[source]

+sympy.polys.densetools.dmp_ground_primitive(f, u, K)[source]
 
Compute content and the primitive form of f in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ, QQ
@@ -2522,7 +2522,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dup_extract(f, g, K)[source]

+sympy.polys.densetools.dup_extract(f, g, K)[source]
 
Extract common content from a pair of polynomials in K[x].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2537,7 +2537,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dmp_ground_extract(f, g, u, K)[source]

+sympy.polys.densetools.dmp_ground_extract(f, g, u, K)[source]
 
Extract common content from a pair of polynomials in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2552,7 +2552,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dup_real_imag(f, K)[source]

+sympy.polys.densetools.dup_real_imag(f, K)[source]
 
Find f1 and f2, such that f(x+I*y) = f1(x,y) + f2(x,y)*I.

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2573,7 +2573,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dup_mirror(f, K)[source]

+sympy.polys.densetools.dup_mirror(f, K)[source]
 
Evaluate efficiently the composition f(-x) in K[x].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2588,7 +2588,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dup_scale(f, a, K)[source]

+sympy.polys.densetools.dup_scale(f, a, K)[source]
 
Evaluate efficiently composition f(a*x) in K[x].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2603,7 +2603,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dup_shift(f, a, K)[source]

+sympy.polys.densetools.dup_shift(f, a, K)[source]
 
Evaluate efficiently Taylor shift f(x + a) in K[x].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2618,7 +2618,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dup_transform(f, p, q, K)[source]

+sympy.polys.densetools.dup_transform(f, p, q, K)[source]
 
Evaluate functional transformation q**n * f(p/q) in K[x].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2633,7 +2633,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dmp_compose(f, g, u, K)[source]

+sympy.polys.densetools.dmp_compose(f, g, u, K)[source]
 
Evaluate functional composition f(g) in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2648,7 +2648,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dup_decompose(f, K)[source]

+sympy.polys.densetools.dup_decompose(f, K)[source]
 
Computes functional decomposition of f in K[x].

 
Given a univariate polynomial f with coefficients in a field of
 characteristic zero, returns list [f_1, f_2, ..., f_n], where:

@@ -2685,7 +2685,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dmp_lift(f, u, K)[source]

+sympy.polys.densetools.dmp_lift(f, u, K)[source]
 
Convert algebraic coefficients to integers in K[X].

 
Examples

 
>>> from sympy.polys import ring, QQ
@@ -2707,7 +2707,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dup_sign_variations(f, K)[source]

+sympy.polys.densetools.dup_sign_variations(f, K)[source]
 
Compute the number of sign variations of f in K[x].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -2722,7 +2722,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dmp_clear_denoms(f, u, K0, K1=None, convert=False)[source]

+sympy.polys.densetools.dmp_clear_denoms(f, u, K0, K1=None, convert=False)[source]
 
Clear denominators, i.e. transform K_0 to K_1.

 
Examples

 
>>> from sympy.polys import ring, QQ
@@ -2742,7 +2742,7 @@ 
Manipulation of dense, multivariate polynomials
 

-sympy.polys.densetools.dmp_revert(f, g, u, K)[source]

+sympy.polys.densetools.dmp_revert(f, g, u, K)[source]
 
Compute f**(-1) mod x**n using Newton iteration.

 
Examples

 
>>> from sympy.polys import ring, QQ
@@ -2762,7 +2762,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 fields.

 

 

-sympy.polys.galoistools.gf_crt(U, M, K=None)[source]

+sympy.polys.galoistools.gf_crt(U, M, K=None)[source]
 
Chinese Remainder Theorem.

 
Given a set of integer residues u_0,...,u_n and a set of
 co-prime integer moduli m_0,...,m_n, returns an integer
@@ -2795,7 +2795,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_crt1(M, K)[source]

+sympy.polys.galoistools.gf_crt1(M, K)[source]
 
First part of the Chinese Remainder Theorem.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -2836,7 +2836,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_crt2(U, M, p, E, S, K)[source]

+sympy.polys.galoistools.gf_crt2(U, M, p, E, S, K)[source]
 
Second part of the Chinese Remainder Theorem.

 
See gf_crt1 for usage.

 
Examples

@@ -2867,7 +2867,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_int(a, p)[source]

+sympy.polys.galoistools.gf_int(a, p)[source]
 
Coerce a mod p to an integer in the range [-p/2, p/2].

 
Examples

 
>>> from sympy.polys.galoistools import gf_int
@@ -2883,7 +2883,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_degree(f)[source]

+sympy.polys.galoistools.gf_degree(f)[source]
 
Return the leading degree of f.

 
Examples

 
>>> from sympy.polys.galoistools import gf_degree
@@ -2899,7 +2899,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_LC(f, K)[source]

+sympy.polys.galoistools.gf_LC(f, K)[source]
 
Return the leading coefficient of f.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -2914,7 +2914,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_TC(f, K)[source]

+sympy.polys.galoistools.gf_TC(f, K)[source]
 
Return the trailing coefficient of f.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -2929,7 +2929,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_strip(f)[source]

+sympy.polys.galoistools.gf_strip(f)[source]
 
Remove leading zeros from f.

 
Examples

 
>>> from sympy.polys.galoistools import gf_strip
@@ -2943,7 +2943,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_trunc(f, p)[source]

+sympy.polys.galoistools.gf_trunc(f, p)[source]
 
Reduce all coefficients modulo p.

 
Examples

 
>>> from sympy.polys.galoistools import gf_trunc
@@ -2957,7 +2957,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_normal(f, p, K)[source]

+sympy.polys.galoistools.gf_normal(f, p, K)[source]
 
Normalize all coefficients in K.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -2972,7 +2972,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_from_dict(f, p, K)[source]

+sympy.polys.galoistools.gf_from_dict(f, p, K)[source]
 
Create a GF(p)[x] polynomial from a dict.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -2987,7 +2987,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_to_dict(f, p, symmetric=True)[source]

+sympy.polys.galoistools.gf_to_dict(f, p, symmetric=True)[source]
 
Convert a GF(p)[x] polynomial to a dict.

 
Examples

 
>>> from sympy.polys.galoistools import gf_to_dict
@@ -3003,7 +3003,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_from_int_poly(f, p)[source]

+sympy.polys.galoistools.gf_from_int_poly(f, p)[source]
 
Create a GF(p)[x] polynomial from Z[x].

 
Examples

 
>>> from sympy.polys.galoistools import gf_from_int_poly
@@ -3017,7 +3017,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_to_int_poly(f, p, symmetric=True)[source]

+sympy.polys.galoistools.gf_to_int_poly(f, p, symmetric=True)[source]
 
Convert a GF(p)[x] polynomial to Z[x].

 
Examples

 
>>> from sympy.polys.galoistools import gf_to_int_poly
@@ -3033,7 +3033,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_neg(f, p, K)[source]

+sympy.polys.galoistools.gf_neg(f, p, K)[source]
 
Negate a polynomial in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3048,7 +3048,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_add_ground(f, a, p, K)[source]

+sympy.polys.galoistools.gf_add_ground(f, a, p, K)[source]
 
Compute f + a where f in GF(p)[x] and a in GF(p).

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3063,7 +3063,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_sub_ground(f, a, p, K)[source]

+sympy.polys.galoistools.gf_sub_ground(f, a, p, K)[source]
 
Compute f - a where f in GF(p)[x] and a in GF(p).

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3078,7 +3078,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_mul_ground(f, a, p, K)[source]

+sympy.polys.galoistools.gf_mul_ground(f, a, p, K)[source]
 
Compute f * a where f in GF(p)[x] and a in GF(p).

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3093,7 +3093,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_quo_ground(f, a, p, K)[source]

+sympy.polys.galoistools.gf_quo_ground(f, a, p, K)[source]
 
Compute f/a where f in GF(p)[x] and a in GF(p).

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3108,7 +3108,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_add(f, g, p, K)[source]

+sympy.polys.galoistools.gf_add(f, g, p, K)[source]
 
Add polynomials in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3123,7 +3123,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_sub(f, g, p, K)[source]

+sympy.polys.galoistools.gf_sub(f, g, p, K)[source]
 
Subtract polynomials in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3138,7 +3138,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_mul(f, g, p, K)[source]

+sympy.polys.galoistools.gf_mul(f, g, p, K)[source]
 
Multiply polynomials in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3153,7 +3153,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_sqr(f, p, K)[source]

+sympy.polys.galoistools.gf_sqr(f, p, K)[source]
 
Square polynomials in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3168,7 +3168,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_add_mul(f, g, h, p, K)[source]

+sympy.polys.galoistools.gf_add_mul(f, g, h, p, K)[source]
 
Returns f + g*h where f, g, h in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3181,7 +3181,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_sub_mul(f, g, h, p, K)[source]

+sympy.polys.galoistools.gf_sub_mul(f, g, h, p, K)[source]
 
Compute f - g*h where f, g, h in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3196,7 +3196,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_expand(F, p, K)[source]

+sympy.polys.galoistools.gf_expand(F, p, K)[source]
 
Expand results of factor() in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3211,7 +3211,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_div(f, g, p, K)[source]

+sympy.polys.galoistools.gf_div(f, g, p, K)[source]
 
Division with remainder in GF(p)[x].

 
Given univariate polynomials f and g with coefficients in a
 finite field with p elements, returns polynomials q and r
@@ -3244,7 +3244,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_rem(f, g, p, K)[source]

+sympy.polys.galoistools.gf_rem(f, g, p, K)[source]
 
Compute polynomial remainder in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3259,7 +3259,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_quo(f, g, p, K)[source]

+sympy.polys.galoistools.gf_quo(f, g, p, K)[source]
 
Compute exact quotient in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3276,7 +3276,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_exquo(f, g, p, K)[source]

+sympy.polys.galoistools.gf_exquo(f, g, p, K)[source]
 
Compute polynomial quotient in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3297,7 +3297,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_lshift(f, n, K)[source]

+sympy.polys.galoistools.gf_lshift(f, n, K)[source]
 
Efficiently multiply f by x**n.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3312,7 +3312,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_rshift(f, n, K)[source]

+sympy.polys.galoistools.gf_rshift(f, n, K)[source]
 
Efficiently divide f by x**n.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3327,7 +3327,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_pow(f, n, p, K)[source]

+sympy.polys.galoistools.gf_pow(f, n, p, K)[source]
 
Compute f**n in GF(p)[x] using repeated squaring.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3342,7 +3342,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_pow_mod(f, n, g, p, K)[source]

+sympy.polys.galoistools.gf_pow_mod(f, n, g, p, K)[source]
 
Compute f**n in GF(p)[x]/(g) using repeated squaring.

 
Given polynomials f and g in GF(p)[x] and a non-negative
 integer n, efficiently computes f**n (mod g) i.e. the remainder
@@ -3367,7 +3367,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_gcd(f, g, p, K)[source]

+sympy.polys.galoistools.gf_gcd(f, g, p, K)[source]
 
Euclidean Algorithm in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3382,7 +3382,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_lcm(f, g, p, K)[source]

+sympy.polys.galoistools.gf_lcm(f, g, p, K)[source]
 
Compute polynomial LCM in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3397,7 +3397,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_cofactors(f, g, p, K)[source]

+sympy.polys.galoistools.gf_cofactors(f, g, p, K)[source]
 
Compute polynomial GCD and cofactors in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3412,7 +3412,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_gcdex(f, g, p, K)[source]

+sympy.polys.galoistools.gf_gcdex(f, g, p, K)[source]
 
Extended Euclidean Algorithm in GF(p)[x].

 
Given polynomials f and g in GF(p)[x], computes polynomials
 s, t and h, such that h = gcd(f, g) and s*f + t*g = h.
@@ -3447,7 +3447,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_monic(f, p, K)[source]

+sympy.polys.galoistools.gf_monic(f, p, K)[source]
 
Compute LC and a monic polynomial in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3462,7 +3462,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_diff(f, p, K)[source]

+sympy.polys.galoistools.gf_diff(f, p, K)[source]
 
Differentiate polynomial in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3477,7 +3477,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_eval(f, a, p, K)[source]

+sympy.polys.galoistools.gf_eval(f, a, p, K)[source]
 
Evaluate f(a) in GF(p) using Horner scheme.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3492,7 +3492,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_multi_eval(f, A, p, K)[source]

+sympy.polys.galoistools.gf_multi_eval(f, A, p, K)[source]
 
Evaluate f(a) for a in [a_1, ..., a_n].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3507,7 +3507,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_compose(f, g, p, K)[source]

+sympy.polys.galoistools.gf_compose(f, g, p, K)[source]
 
Compute polynomial composition f(g) in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3522,7 +3522,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_compose_mod(g, h, f, p, K)[source]

+sympy.polys.galoistools.gf_compose_mod(g, h, f, p, K)[source]
 
Compute polynomial composition g(h) in GF(p)[x]/(f).

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3537,7 +3537,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_trace_map(a, b, c, n, f, p, K)[source]

+sympy.polys.galoistools.gf_trace_map(a, b, c, n, f, p, K)[source]
 
Compute polynomial trace map in GF(p)[x]/(f).

 
Given a polynomial f in GF(p)[x], polynomials a, b,
 c in the quotient ring GF(p)[x]/(f) such that b = c**t
@@ -3570,7 +3570,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_random(n, p, K)[source]

+sympy.polys.galoistools.gf_random(n, p, K)[source]
 
Generate a random polynomial in GF(p)[x] of degree n.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3583,7 +3583,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_irreducible(n, p, K)[source]

+sympy.polys.galoistools.gf_irreducible(n, p, K)[source]
 
Generate random irreducible polynomial of degree n in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3596,7 +3596,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_irreducible_p(f, p, K)[source]

+sympy.polys.galoistools.gf_irreducible_p(f, p, K)[source]
 
Test irreducibility of a polynomial f in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3613,7 +3613,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_sqf_p(f, p, K)[source]

+sympy.polys.galoistools.gf_sqf_p(f, p, K)[source]
 
Return True if f is square-free in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3630,7 +3630,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_sqf_part(f, p, K)[source]

+sympy.polys.galoistools.gf_sqf_part(f, p, K)[source]
 
Return square-free part of a GF(p)[x] polynomial.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3645,7 +3645,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_sqf_list(f, p, K, all=False)[source]

+sympy.polys.galoistools.gf_sqf_list(f, p, K, all=False)[source]
 
Return the square-free decomposition of a GF(p)[x] polynomial.

 
Given a polynomial f in GF(p)[x], returns the leading coefficient
 of f and a square-free decomposition f_1**e_1 f_2**e_2 ... f_k**e_k
@@ -3690,7 +3690,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_Qmatrix(f, p, K)[source]

+sympy.polys.galoistools.gf_Qmatrix(f, p, K)[source]
 
Calculate Berlekamp’s Q matrix.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3713,7 +3713,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_Qbasis(Q, p, K)[source]

+sympy.polys.galoistools.gf_Qbasis(Q, p, K)[source]
 
Compute a basis of the kernel of Q.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3732,7 +3732,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_berlekamp(f, p, K)[source]

+sympy.polys.galoistools.gf_berlekamp(f, p, K)[source]
 
Factor a square-free f in GF(p)[x] for small p.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3747,7 +3747,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_zassenhaus(f, p, K)[source]

+sympy.polys.galoistools.gf_zassenhaus(f, p, K)[source]
 
Factor a square-free f in GF(p)[x] for medium p.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3762,7 +3762,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_shoup(f, p, K)[source]

+sympy.polys.galoistools.gf_shoup(f, p, K)[source]
 
Factor a square-free f in GF(p)[x] for large p.

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3777,7 +3777,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_factor_sqf(f, p, K, method=None)[source]

+sympy.polys.galoistools.gf_factor_sqf(f, p, K, method=None)[source]
 
Factor a square-free polynomial f in GF(p)[x].

 
Examples

 
>>> from sympy.polys.domains import ZZ
@@ -3792,7 +3792,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_factor(f, p, K)[source]

+sympy.polys.galoistools.gf_factor(f, p, K)[source]
 
Factor (non square-free) polynomials in GF(p)[x].

 
Given a possibly non square-free polynomial f in GF(p)[x],
 returns its complete factorization into irreducibles:

@@ -3841,7 +3841,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_value(f, a)[source]

+sympy.polys.galoistools.gf_value(f, a)[source]
 
Value of polynomial ‘f’ at ‘a’ in field R.

 
Examples

 
>>> from sympy.polys.galoistools import gf_value
@@ -3855,7 +3855,7 @@ 
Manipulation of dense, univariate polynomials with finite field coefficients
 
 

 

-sympy.polys.galoistools.gf_csolve(f, n)[source]

+sympy.polys.galoistools.gf_csolve(f, n)[source]
 
To solve f(x) congruent 0 mod(n).

 
n is divided into canonical factors and f(x) cong 0 mod(p**e) will be
 solved for each factor. Applying the Chinese Remainder Theorem to the
@@ -3901,7 +3901,7 @@ 
Manipulation of sparse, distributed polynomials and vectors\(f_1, f_2, \ldots\).

 

 

-sympy.polys.distributedmodules.sdm_monomial_mul(M, X)[source]

+sympy.polys.distributedmodules.sdm_monomial_mul(M, X)[source]
 
Multiply tuple X representing a monomial of \(K[X]\) into the tuple
 M representing a monomial of \(F\).

 
Examples

@@ -3915,7 +3915,7 @@ 
Manipulation of sparse, distributed polynomials and vectors
 

-sympy.polys.distributedmodules.sdm_monomial_deg(M)[source]

+sympy.polys.distributedmodules.sdm_monomial_deg(M)[source]
 
Return the total degree of M.

 
Examples

 
For example, the total degree of \(x^2 y f_5\) is 3:

@@ -3928,7 +3928,7 @@ 
Manipulation of sparse, distributed polynomials and vectors
 

-sympy.polys.distributedmodules.sdm_monomial_divides(A, B)[source]

+sympy.polys.distributedmodules.sdm_monomial_divides(A, B)[source]
 
Does there exist a (polynomial) monomial X such that XA = B?

 
Examples

 
Positive examples:

@@ -3974,19 +3974,19 @@ 
Manipulation of sparse, distributed polynomials and vectors
 

-sympy.polys.distributedmodules.sdm_LC(f, K)[source]

+sympy.polys.distributedmodules.sdm_LC(f, K)[source]
 
Returns the leading coefficient of f.

 

 
 

 

-sympy.polys.distributedmodules.sdm_to_dict(f)[source]

+sympy.polys.distributedmodules.sdm_to_dict(f)[source]
 
Make a dictionary from a distributed polynomial.

 

 
 

 

-sympy.polys.distributedmodules.sdm_from_dict(d, O)[source]

+sympy.polys.distributedmodules.sdm_from_dict(d, O)[source]
 
Create an sdm from a dictionary.

 
Here O is the monomial order to use.

 
Examples

@@ -4001,7 +4001,7 @@ 
Manipulation of sparse, distributed polynomials and vectors
 

-sympy.polys.distributedmodules.sdm_add(f, g, O, K)[source]

+sympy.polys.distributedmodules.sdm_add(f, g, O, K)[source]
 
Add two module elements f, g.

 
Addition is done over the ground field K, monomials are ordered
 according to O.

@@ -4033,7 +4033,7 @@ 
Manipulation of sparse, distributed polynomials and vectors
 

-sympy.polys.distributedmodules.sdm_LM(f)[source]

+sympy.polys.distributedmodules.sdm_LM(f)[source]
 
Returns the leading monomial of f.

 
Only valid if \(f \ne 0\).

 
Examples

@@ -4048,7 +4048,7 @@ 
Manipulation of sparse, distributed polynomials and vectors
 

-sympy.polys.distributedmodules.sdm_LT(f)[source]

+sympy.polys.distributedmodules.sdm_LT(f)[source]
 
Returns the leading term of f.

 
Only valid if \(f \ne 0\).

 
Examples

@@ -4063,7 +4063,7 @@ 
Manipulation of sparse, distributed polynomials and vectors
 

-sympy.polys.distributedmodules.sdm_mul_term(f, term, O, K)[source]

+sympy.polys.distributedmodules.sdm_mul_term(f, term, O, K)[source]
 
Multiply a distributed module element f by a (polynomial) term term.

 
Multiplication of coefficients is done over the ground field K, and
 monomials are ordered according to O.

@@ -4095,13 +4095,13 @@ 
Manipulation of sparse, distributed polynomials and vectors
 

-sympy.polys.distributedmodules.sdm_zero()[source]

+sympy.polys.distributedmodules.sdm_zero()[source]
 
Return the zero module element.

 

 
 

 

-sympy.polys.distributedmodules.sdm_deg(f)[source]

+sympy.polys.distributedmodules.sdm_deg(f)[source]
 
Degree of f.

 
This is the maximum of the degrees of all its monomials.
 Invalid if f is zero.

@@ -4115,7 +4115,7 @@ 
Manipulation of sparse, distributed polynomials and vectors
 

-sympy.polys.distributedmodules.sdm_from_vector(vec, O, K, **opts)[source]

+sympy.polys.distributedmodules.sdm_from_vector(vec, O, K, **opts)[source]
 
Create an sdm from an iterable of expressions.

 
Coefficients are created in the ground field K, and terms are ordered
 according to monomial order O. Named arguments are passed on to the
@@ -4132,7 +4132,7 @@ 
Manipulation of sparse, distributed polynomials and vectors
 

-sympy.polys.distributedmodules.sdm_to_vector(f, gens, K, n=None)[source]

+sympy.polys.distributedmodules.sdm_to_vector(f, gens, K, n=None)[source]
 
Convert sdm f into a list of polynomial expressions.

 
The generators for the polynomial ring are specified via gens. The rank
 of the module is guessed, or passed via n. The ground field is assumed
@@ -4206,7 +4206,7 @@ 
Classical remainder sequence
 

-sympy.polys.euclidtools.dmp_half_gcdex(f, g, u, K)[source]

+sympy.polys.euclidtools.dmp_half_gcdex(f, g, u, K)[source]
 
Half extended Euclidean algorithm in \(F[X]\).

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -4217,7 +4217,7 @@ 
Classical remainder sequence
 

-sympy.polys.euclidtools.dmp_gcdex(f, g, u, K)[source]

+sympy.polys.euclidtools.dmp_gcdex(f, g, u, K)[source]
 
Extended Euclidean algorithm in \(F[X]\).

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -4228,7 +4228,7 @@ 
Classical remainder sequence
 

-sympy.polys.euclidtools.dmp_invert(f, g, u, K)[source]

+sympy.polys.euclidtools.dmp_invert(f, g, u, K)[source]
 
Compute multiplicative inverse of \(f\) modulo \(g\) in \(F[X]\).

 
Examples

 
>>> from sympy.polys import ring, QQ
@@ -4239,7 +4239,7 @@ 
Classical remainder sequence
 

-sympy.polys.euclidtools.dmp_euclidean_prs(f, g, u, K)[source]

+sympy.polys.euclidtools.dmp_euclidean_prs(f, g, u, K)[source]
 
Euclidean polynomial remainder sequence (PRS) in \(K[X]\).

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -4279,7 +4279,7 @@ 
Simplified remainder sequences
 

-sympy.polys.euclidtools.dmp_primitive_prs(f, g, u, K)[source]

+sympy.polys.euclidtools.dmp_primitive_prs(f, g, u, K)[source]
 
Primitive polynomial remainder sequence (PRS) in \(K[X]\).

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -4397,7 +4397,7 @@ 
Subresultant sequence
 

 

-sympy.polys.euclidtools.dmp_inner_subresultants(f, g, u, K)[source]

+sympy.polys.euclidtools.dmp_inner_subresultants(f, g, u, K)[source]
 
Subresultant PRS algorithm in \(K[X]\).

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -4424,7 +4424,7 @@ 
Subresultant sequence
 

-sympy.polys.euclidtools.dmp_subresultants(f, g, u, K)[source]

+sympy.polys.euclidtools.dmp_subresultants(f, g, u, K)[source]
 
Computes subresultant PRS of two polynomials in \(K[X]\).

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -4447,7 +4447,7 @@ 
Subresultant sequence
 

-sympy.polys.euclidtools.dmp_prs_resultant(f, g, u, K)[source]

+sympy.polys.euclidtools.dmp_prs_resultant(f, g, u, K)[source]
 
Resultant algorithm in \(K[X]\) using subresultant PRS.

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -4477,7 +4477,7 @@ 
Subresultant sequence
 

-sympy.polys.euclidtools.dmp_zz_modular_resultant(f, g, p, u, K)[source]

+sympy.polys.euclidtools.dmp_zz_modular_resultant(f, g, p, u, K)[source]
 
Compute resultant of \(f\) and \(g\) modulo a prime \(p\).

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -4496,7 +4496,7 @@ 
Subresultant sequence
 

-sympy.polys.euclidtools.dmp_zz_collins_resultant(f, g, u, K)[source]

+sympy.polys.euclidtools.dmp_zz_collins_resultant(f, g, u, K)[source]
 
Collins’s modular resultant algorithm in \(Z[X]\).

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -4515,7 +4515,7 @@ 
Subresultant sequence
 

-sympy.polys.euclidtools.dmp_qq_collins_resultant(f, g, u, K0)[source]

+sympy.polys.euclidtools.dmp_qq_collins_resultant(f, g, u, K0)[source]
 
Collins’s modular resultant algorithm in \(Q[X]\).

 
Examples

 
>>> from sympy.polys import ring, QQ
@@ -4534,7 +4534,7 @@ 
Subresultant sequence
 

-sympy.polys.euclidtools.dmp_resultant(f, g, u, K, includePRS=False)[source]

+sympy.polys.euclidtools.dmp_resultant(f, g, u, K, includePRS=False)[source]
 
Computes resultant of two polynomials in \(K[X]\).

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -4553,7 +4553,7 @@ 
Subresultant sequence
 

-sympy.polys.euclidtools.dmp_discriminant(f, u, K)[source]

+sympy.polys.euclidtools.dmp_discriminant(f, u, K)[source]
 
Computes discriminant of a polynomial in \(K[X]\).

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -4568,7 +4568,7 @@ 
Subresultant sequence
 

-sympy.polys.euclidtools.dmp_rr_prs_gcd(f, g, u, K)[source]

+sympy.polys.euclidtools.dmp_rr_prs_gcd(f, g, u, K)[source]
 
Computes polynomial GCD using subresultants over a ring.

 
Returns (h, cff, cfg) such that a = gcd(f, g), cff = quo(f, h),
 and cfg = quo(g, h).

@@ -4589,7 +4589,7 @@ 
Subresultant sequence
 

-sympy.polys.euclidtools.dmp_ff_prs_gcd(f, g, u, K)[source]

+sympy.polys.euclidtools.dmp_ff_prs_gcd(f, g, u, K)[source]
 
Computes polynomial GCD using subresultants over a field.

 
Returns (h, cff, cfg) such that a = gcd(f, g), cff = quo(f, h),
 and cfg = quo(g, h).

@@ -4610,7 +4610,7 @@ 
Subresultant sequence
 

-sympy.polys.euclidtools.dmp_zz_heu_gcd(f, g, u, K)[source]

+sympy.polys.euclidtools.dmp_zz_heu_gcd(f, g, u, K)[source]
 
Heuristic polynomial GCD in \(Z[X]\).

 
Given univariate polynomials \(f\) and \(g\) in \(Z[X]\), returns
 their GCD and cofactors, i.e. polynomials h, cff and cfg
@@ -4652,7 +4652,7 @@ 
Subresultant sequence
 

-sympy.polys.euclidtools.dmp_qq_heu_gcd(f, g, u, K0)[source]

+sympy.polys.euclidtools.dmp_qq_heu_gcd(f, g, u, K0)[source]
 
Heuristic polynomial GCD in \(Q[X]\).

 
Returns (h, cff, cfg) such that a = gcd(f, g),
 cff = quo(f, h), and cfg = quo(g, h).

@@ -4673,7 +4673,7 @@ 
Subresultant sequence
 

-sympy.polys.euclidtools.dmp_inner_gcd(f, g, u, K)[source]

+sympy.polys.euclidtools.dmp_inner_gcd(f, g, u, K)[source]
 
Computes polynomial GCD and cofactors of \(f\) and \(g\) in \(K[X]\).

 
Returns (h, cff, cfg) such that a = gcd(f, g),
 cff = quo(f, h), and cfg = quo(g, h).

@@ -4694,7 +4694,7 @@ 
Subresultant sequence
 

-sympy.polys.euclidtools.dmp_gcd(f, g, u, K)[source]

+sympy.polys.euclidtools.dmp_gcd(f, g, u, K)[source]
 
Computes polynomial GCD of \(f\) and \(g\) in \(K[X]\).

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -4713,7 +4713,7 @@ 
Subresultant sequence
 

-sympy.polys.euclidtools.dmp_lcm(f, g, u, K)[source]

+sympy.polys.euclidtools.dmp_lcm(f, g, u, K)[source]
 
Computes polynomial LCM of \(f\) and \(g\) in \(K[X]\).

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -4732,7 +4732,7 @@ 
Subresultant sequence
 

-sympy.polys.euclidtools.dmp_content(f, u, K)[source]

+sympy.polys.euclidtools.dmp_content(f, u, K)[source]
 
Returns GCD of multivariate coefficients.

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -4747,7 +4747,7 @@ 
Subresultant sequence
 

-sympy.polys.euclidtools.dmp_primitive(f, u, K)[source]

+sympy.polys.euclidtools.dmp_primitive(f, u, K)[source]
 
Returns multivariate content and a primitive polynomial.

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -4762,7 +4762,7 @@ 
Subresultant sequence
 

-sympy.polys.euclidtools.dmp_cancel(f, g, u, K, include=True)[source]

+sympy.polys.euclidtools.dmp_cancel(f, g, u, K, include=True)[source]
 
Cancel common factors in a rational function \(f/g\).

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -4778,7 +4778,7 @@ 
Subresultant sequencePolynomial factorization in characteristic zero:

 

 

-sympy.polys.factortools.dup_trial_division(f, factors, K)[source]

+sympy.polys.factortools.dup_trial_division(f, factors, K)[source]
 
Determine multiplicities of factors for a univariate polynomial
 using trial division.

 
An error will be raised if any factor does not divide f.

@@ -4786,7 +4786,7 @@ 
Subresultant sequence
 

-sympy.polys.factortools.dmp_trial_division(f, factors, u, K)[source]

+sympy.polys.factortools.dmp_trial_division(f, factors, u, K)[source]
 
Determine multiplicities of factors for a multivariate polynomial
 using trial division.

 
An error will be raised if any factor does not divide f.

@@ -4794,7 +4794,7 @@ 
Subresultant sequence
 

-sympy.polys.factortools.dup_zz_mignotte_bound(f, K)[source]

+sympy.polys.factortools.dup_zz_mignotte_bound(f, K)[source]
 
The Knuth-Cohen variant of Mignotte bound for
 univariate polynomials in K[x].

 
Examples

@@ -4830,13 +4830,13 @@ 
Subresultant sequence
 

-sympy.polys.factortools.dmp_zz_mignotte_bound(f, u, K)[source]

+sympy.polys.factortools.dmp_zz_mignotte_bound(f, u, K)[source]
 
Mignotte bound for multivariate polynomials in \(K[X]\).

 

 
 

 

-sympy.polys.factortools.dup_zz_hensel_step(m, f, g, h, s, t, K)[source]

+sympy.polys.factortools.dup_zz_hensel_step(m, f, g, h, s, t, K)[source]
 
One step in Hensel lifting in \(Z[x]\).

 
Given positive integer \(m\) and \(Z[x]\) polynomials \(f\), \(g\), \(h\), \(s\)
 and \(t\) such that:

@@ -4867,7 +4867,7 @@ 
Subresultant sequence
 

-sympy.polys.factortools.dup_zz_hensel_lift(p, f, f_list, l, K)[source]

+sympy.polys.factortools.dup_zz_hensel_lift(p, f, f_list, l, K)[source]
 
Multifactor Hensel lifting in \(Z[x]\).

 
Given a prime \(p\), polynomial \(f\) over \(Z[x]\) such that \(lc(f)\)
 is a unit modulo \(p\), monic pair-wise coprime polynomials \(f_i\)
@@ -4893,19 +4893,19 @@ 
Subresultant sequence
 

-sympy.polys.factortools.dup_zz_zassenhaus(f, K)[source]

+sympy.polys.factortools.dup_zz_zassenhaus(f, K)[source]
 
Factor primitive square-free polynomials in \(Z[x]\).

 

 
 

 

-sympy.polys.factortools.dup_zz_irreducible_p(f, K)[source]

+sympy.polys.factortools.dup_zz_irreducible_p(f, K)[source]
 
Test irreducibility using Eisenstein’s criterion.

 

 
 

 

-sympy.polys.factortools.dup_cyclotomic_p(f, K, irreducible=False)[source]

+sympy.polys.factortools.dup_cyclotomic_p(f, K, irreducible=False)[source]
 
Efficiently test if f is a cyclotomic polynomial.

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -4930,13 +4930,13 @@ 
Subresultant sequence
 

-sympy.polys.factortools.dup_zz_cyclotomic_poly(n, K)[source]

+sympy.polys.factortools.dup_zz_cyclotomic_poly(n, K)[source]
 
Efficiently generate n-th cyclotomic polynomial.

 

 
 

 

-sympy.polys.factortools.dup_zz_cyclotomic_factor(f, K)[source]

+sympy.polys.factortools.dup_zz_cyclotomic_factor(f, K)[source]
 
Efficiently factor polynomials \(x**n - 1\) and \(x**n + 1\) in \(Z[x]\).

 
Given a univariate polynomial \(f\) in \(Z[x]\) returns a list of factors
 of \(f\), provided that \(f\) is in the form \(x**n - 1\) or \(x**n + 1\) for
@@ -4955,13 +4955,13 @@ 
Subresultant sequence
 

-sympy.polys.factortools.dup_zz_factor_sqf(f, K)[source]

+sympy.polys.factortools.dup_zz_factor_sqf(f, K)[source]
 
Factor square-free (non-primitive) polynomials in \(Z[x]\).

 

 
 

 

-sympy.polys.factortools.dup_zz_factor(f, K)[source]

+sympy.polys.factortools.dup_zz_factor(f, K)[source]
 
Factor (non square-free) polynomials in \(Z[x]\).

 
Given a univariate polynomial \(f\) in \(Z[x]\) computes its complete
 factorization \(f_1, ..., f_n\) into irreducibles over integers:

@@ -5005,43 +5005,43 @@ 
Subresultant sequence
 

-sympy.polys.factortools.dmp_zz_wang_non_divisors(E, cs, ct, K)[source]

+sympy.polys.factortools.dmp_zz_wang_non_divisors(E, cs, ct, K)[source]
 
Wang/EEZ: Compute a set of valid divisors.

 

 
 

 

-sympy.polys.factortools.dmp_zz_wang_test_points(f, T, ct, A, u, K)[source]

+sympy.polys.factortools.dmp_zz_wang_test_points(f, T, ct, A, u, K)[source]
 
Wang/EEZ: Test evaluation points for suitability.

 

 
 

 

-sympy.polys.factortools.dmp_zz_wang_lead_coeffs(f, T, cs, E, H, A, u, K)[source]

+sympy.polys.factortools.dmp_zz_wang_lead_coeffs(f, T, cs, E, H, A, u, K)[source]
 
Wang/EEZ: Compute correct leading coefficients.

 

 
 

 

-sympy.polys.factortools.dup_zz_diophantine(F, m, p, K)[source]

+sympy.polys.factortools.dup_zz_diophantine(F, m, p, K)[source]
 
Wang/EEZ: Solve univariate Diophantine equations.

 

 
 

 

-sympy.polys.factortools.dmp_zz_diophantine(F, c, A, d, p, u, K)[source]

+sympy.polys.factortools.dmp_zz_diophantine(F, c, A, d, p, u, K)[source]
 
Wang/EEZ: Solve multivariate Diophantine equations.

 

 
 

 

-sympy.polys.factortools.dmp_zz_wang_hensel_lifting(f, H, LC, A, p, u, K)[source]

+sympy.polys.factortools.dmp_zz_wang_hensel_lifting(f, H, LC, A, p, u, K)[source]
 
Wang/EEZ: Parallel Hensel lifting algorithm.

 

 
 

 

-sympy.polys.factortools.dmp_zz_wang(f, u, K, mod=None, seed=None)[source]

+sympy.polys.factortools.dmp_zz_wang(f, u, K, mod=None, seed=None)[source]
 
Factor primitive square-free polynomials in \(Z[X]\).

 
Given a multivariate polynomial \(f\) in \(Z[x_1,...,x_n]\), which is
 primitive and square-free in \(x_1\), computes factorization of \(f\) into
@@ -5074,7 +5074,7 @@ 
Subresultant sequence
 

-sympy.polys.factortools.dmp_zz_factor(f, u, K)[source]

+sympy.polys.factortools.dmp_zz_factor(f, u, K)[source]
 
Factor (non square-free) polynomials in \(Z[X]\).

 
Given a multivariate polynomial \(f\) in \(Z[x]\) computes its complete
 factorization \(f_1, \dots, f_n\) into irreducibles over integers:

@@ -5112,31 +5112,31 @@ 
Subresultant sequence
 

-sympy.polys.factortools.dup_qq_i_factor(f, K0)[source]

+sympy.polys.factortools.dup_qq_i_factor(f, K0)[source]
 
Factor univariate polynomials into irreducibles in \(QQ_I[x]\).

 

 
 

 

-sympy.polys.factortools.dup_zz_i_factor(f, K0)[source]

+sympy.polys.factortools.dup_zz_i_factor(f, K0)[source]
 
Factor univariate polynomials into irreducibles in \(ZZ_I[x]\).

 

 
 

 

-sympy.polys.factortools.dmp_qq_i_factor(f, u, K0)[source]

+sympy.polys.factortools.dmp_qq_i_factor(f, u, K0)[source]
 
Factor multivariate polynomials into irreducibles in \(QQ_I[X]\).

 

 
 

 

-sympy.polys.factortools.dmp_zz_i_factor(f, u, K0)[source]

+sympy.polys.factortools.dmp_zz_i_factor(f, u, K0)[source]
 
Factor multivariate polynomials into irreducibles in \(ZZ_I[X]\).

 

 
 

 

-sympy.polys.factortools.dup_ext_factor(f, K)[source]

+sympy.polys.factortools.dup_ext_factor(f, K)[source]
 
Factor univariate polynomials over algebraic number fields.

 
The domain \(K\) must be an algebraic number field \(k(a)\) (see QQ<a>).

 
Examples

@@ -5196,7 +5196,7 @@ 
Subresultant sequence
 

-sympy.polys.factortools.dmp_ext_factor(f, u, K)[source]

+sympy.polys.factortools.dmp_ext_factor(f, u, K)[source]
 
Factor multivariate polynomials over algebraic number fields.

 
The domain \(K\) must be an algebraic number field \(k(a)\) (see QQ<a>).

 
Examples

@@ -5240,50 +5240,50 @@ 
Subresultant sequence
 

-sympy.polys.factortools.dup_gf_factor(f, K)[source]

+sympy.polys.factortools.dup_gf_factor(f, K)[source]
 
Factor univariate polynomials over finite fields.

 

 
 

 

-sympy.polys.factortools.dmp_gf_factor(f, u, K)[source]

+sympy.polys.factortools.dmp_gf_factor(f, u, K)[source]
 
Factor multivariate polynomials over finite fields.

 

 
 

 

-sympy.polys.factortools.dup_factor_list(f, K0)[source]

+sympy.polys.factortools.dup_factor_list(f, K0)[source]
 
Factor univariate polynomials into irreducibles in \(K[x]\).

 

 
 

 

-sympy.polys.factortools.dup_factor_list_include(f, K)[source]

+sympy.polys.factortools.dup_factor_list_include(f, K)[source]
 
Factor univariate polynomials into irreducibles in \(K[x]\).

 

 
 

 

-sympy.polys.factortools.dmp_factor_list(f, u, K0)[source]

+sympy.polys.factortools.dmp_factor_list(f, u, K0)[source]
 
Factor multivariate polynomials into irreducibles in \(K[X]\).

 

 
 

 

-sympy.polys.factortools.dmp_factor_list_include(f, u, K)[source]

+sympy.polys.factortools.dmp_factor_list_include(f, u, K)[source]
 
Factor multivariate polynomials into irreducibles in \(K[X]\).

 

 
 

 

-sympy.polys.factortools.dup_irreducible_p(f, K)[source]

+sympy.polys.factortools.dup_irreducible_p(f, K)[source]
 
Returns True if a univariate polynomial f has no factors
 over its domain.

 

 
 

 

-sympy.polys.factortools.dmp_irreducible_p(f, u, K)[source]

+sympy.polys.factortools.dmp_irreducible_p(f, u, K)[source]
 
Returns True if a multivariate polynomial f has no factors
 over its domain.

 

@@ -5291,7 +5291,7 @@ 
Subresultant sequenceSquare-free factorization:

 

 

-sympy.polys.sqfreetools.dup_sqf_p(f, K)[source]

+sympy.polys.sqfreetools.dup_sqf_p(f, K)[source]
 
Return True if f is a square-free polynomial in K[x].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -5308,7 +5308,7 @@ 
Subresultant sequence
 

-sympy.polys.sqfreetools.dmp_sqf_p(f, u, K)[source]

+sympy.polys.sqfreetools.dmp_sqf_p(f, u, K)[source]
 
Return True if f is a square-free polynomial in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -5325,7 +5325,7 @@ 
Subresultant sequence
 

-sympy.polys.sqfreetools.dup_sqf_norm(f, K)[source]

+sympy.polys.sqfreetools.dup_sqf_norm(f, K)[source]
 
Find a shift of \(f\) in \(K[x]\) that has square-free norm.

 
The domain \(K\) must be an algebraic number field \(k(a)\) (see QQ<a>).

 
Returns \((s,g,r)\), such that \(g(x)=f(x-sa)\), \(r(x)=\text{Norm}(g(x))\) and
@@ -5387,7 +5387,7 @@ 
Subresultant sequence
 

-sympy.polys.sqfreetools.dmp_sqf_norm(f, u, K)[source]

+sympy.polys.sqfreetools.dmp_sqf_norm(f, u, K)[source]
 
Find a shift of f in K[X] that has square-free norm.

 
The domain \(K\) must be an algebraic number field \(k(a)\) (see QQ<a>).

 
Returns \((s,g,r)\), such that \(g(x_1,x_2,\cdots)=f(x_1-s_1 a, x_2 - s_2 a,
@@ -5450,7 +5450,7 @@ 
Subresultant sequence
 

-sympy.polys.sqfreetools.dmp_norm(f, u, K)[source]

+sympy.polys.sqfreetools.dmp_norm(f, u, K)[source]
 
Norm of f in K[X], often not square-free.

 
The domain \(K\) must be an algebraic number field \(k(a)\) (see QQ<a>).

 
Examples

@@ -5518,19 +5518,19 @@ 
Subresultant sequence
 

-sympy.polys.sqfreetools.dup_gf_sqf_part(f, K)[source]

+sympy.polys.sqfreetools.dup_gf_sqf_part(f, K)[source]
 
Compute square-free part of f in GF(p)[x].

 

 
 

 

-sympy.polys.sqfreetools.dmp_gf_sqf_part(f, u, K)[source]

+sympy.polys.sqfreetools.dmp_gf_sqf_part(f, u, K)[source]
 
Compute square-free part of f in GF(p)[X].

 

 
 

 

-sympy.polys.sqfreetools.dup_sqf_part(f, K)[source]

+sympy.polys.sqfreetools.dup_sqf_part(f, K)[source]
 
Returns square-free part of a polynomial in K[x].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -5549,7 +5549,7 @@ 
Subresultant sequence
 

-sympy.polys.sqfreetools.dmp_sqf_part(f, u, K)[source]

+sympy.polys.sqfreetools.dmp_sqf_part(f, u, K)[source]
 
Returns square-free part of a polynomial in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -5564,19 +5564,19 @@ 
Subresultant sequence
 

-sympy.polys.sqfreetools.dup_gf_sqf_list(f, K, all=False)[source]

+sympy.polys.sqfreetools.dup_gf_sqf_list(f, K, all=False)[source]
 
Compute square-free decomposition of f in GF(p)[x].

 

 
 

 

-sympy.polys.sqfreetools.dmp_gf_sqf_list(f, u, K, all=False)[source]

+sympy.polys.sqfreetools.dmp_gf_sqf_list(f, u, K, all=False)[source]
 
Compute square-free decomposition of f in GF(p)[X].

 

 
 

 

-sympy.polys.sqfreetools.dup_sqf_list(f, K, all=False)[source]

+sympy.polys.sqfreetools.dup_sqf_list(f, K, all=False)[source]
 
Return square-free decomposition of a polynomial in K[x].

 
Uses Yun’s algorithm from [Yun76].

 
Examples

@@ -5610,7 +5610,7 @@ 
Subresultant sequence
 

-sympy.polys.sqfreetools.dup_sqf_list_include(f, K, all=False)[source]

+sympy.polys.sqfreetools.dup_sqf_list_include(f, K, all=False)[source]
 
Return square-free decomposition of a polynomial in K[x].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -5630,7 +5630,7 @@ 
Subresultant sequence
 

-sympy.polys.sqfreetools.dmp_sqf_list(f, u, K, all=False)[source]

+sympy.polys.sqfreetools.dmp_sqf_list(f, u, K, all=False)[source]
 
Return square-free decomposition of a polynomial in \(K[X]\).

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -5668,7 +5668,7 @@ 
Subresultant sequence
 

-sympy.polys.sqfreetools.dmp_sqf_list_include(f, u, K, all=False)[source]

+sympy.polys.sqfreetools.dmp_sqf_list_include(f, u, K, all=False)[source]
 
Return square-free decomposition of a polynomial in K[x].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -5688,7 +5688,7 @@ 
Subresultant sequence
 

-sympy.polys.sqfreetools.dup_gff_list(f, K)[source]

+sympy.polys.sqfreetools.dup_gff_list(f, K)[source]
 
Compute greatest factorial factorization of f in K[x].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -5703,7 +5703,7 @@ 
Subresultant sequence
 

-sympy.polys.sqfreetools.dmp_gff_list(f, u, K)[source]

+sympy.polys.sqfreetools.dmp_gff_list(f, u, K)[source]
 
Compute greatest factorial factorization of f in K[X].

 
Examples

 
>>> from sympy.polys import ring, ZZ
@@ -5723,7 +5723,7 @@ 
Groebner basis algorithms
 

-sympy.polys.groebnertools.groebner(seq, ring, method=None)[source]

+sympy.polys.groebnertools.groebner(seq, ring, method=None)[source]
 
Computes Groebner basis for a set of polynomials in \(K[X]\).

 
Wrapper around the (default) improved Buchberger and the other algorithms
 for computing Groebner bases. The choice of algorithm can be changed via
@@ -5733,14 +5733,14 @@ 
Groebner basis algorithms
 

-sympy.polys.groebnertools.spoly(p1, p2, ring)[source]

+sympy.polys.groebnertools.spoly(p1, p2, ring)[source]
 
Compute LCM(LM(p1), LM(p2))/LM(p1)*p1 - LCM(LM(p1), LM(p2))/LM(p2)*p2
 This is the S-poly provided p1 and p2 are monic

 

 
 

 

-sympy.polys.groebnertools.red_groebner(G, ring)[source]

+sympy.polys.groebnertools.red_groebner(G, ring)[source]
 
Compute reduced Groebner basis, from BeckerWeispfenning93, p. 216

 
Selects a subset of generators, that already generate the ideal
 and computes a reduced Groebner basis for them.

@@ -5748,25 +5748,25 @@ 
Groebner basis algorithms
 

-sympy.polys.groebnertools.is_groebner(G, ring)[source]

+sympy.polys.groebnertools.is_groebner(G, ring)[source]
 
Check if G is a Groebner basis.

 

 
 

 

-sympy.polys.groebnertools.is_minimal(G, ring)[source]

+sympy.polys.groebnertools.is_minimal(G, ring)[source]
 
Checks if G is a minimal Groebner basis.

 

 
 

 

-sympy.polys.groebnertools.is_reduced(G, ring)[source]

+sympy.polys.groebnertools.is_reduced(G, ring)[source]
 
Checks if G is a reduced Groebner basis.

 

 
 

 

-sympy.polys.fglmtools.matrix_fglm(F, ring, O_to)[source]

+sympy.polys.fglmtools.matrix_fglm(F, ring, O_to)[source]
 
Converts the reduced Groebner basis F of a zero-dimensional
 ideal w.r.t. O_from to a reduced Groebner basis
 w.r.t. O_to.

@@ -5784,7 +5784,7 @@ 
Groebner basis algorithms
 

-sympy.polys.distributedmodules.sdm_spoly(f, g, O, K, phantom=None)[source]

+sympy.polys.distributedmodules.sdm_spoly(f, g, O, K, phantom=None)[source]
 
Compute the generalized s-polynomial of f and g.

 
The ground field is assumed to be K, and monomials ordered according to
 O.

@@ -5812,7 +5812,7 @@ 
Groebner basis algorithms
 

-sympy.polys.distributedmodules.sdm_ecart(f)[source]

+sympy.polys.distributedmodules.sdm_ecart(f)[source]
 
Compute the ecart of f.

 
This is defined to be the difference of the total degree of \(f\) and the
 total degree of the leading monomial of \(f\) [SCA, defn 2.3.7].

@@ -5829,7 +5829,7 @@ 
Groebner basis algorithms
 

-sympy.polys.distributedmodules.sdm_nf_mora(f, G, O, K, phantom=None)[source]

+sympy.polys.distributedmodules.sdm_nf_mora(f, G, O, K, phantom=None)[source]
 
Compute a weak normal form of f with respect to G and order O.

 
The ground field is assumed to be K, and monomials ordered according to
 O.

@@ -5851,7 +5851,7 @@ 
Groebner basis algorithms
 

-sympy.polys.distributedmodules.sdm_groebner(G, NF, O, K, extended=False)[source]

+sympy.polys.distributedmodules.sdm_groebner(G, NF, O, K, extended=False)[source]
 
Compute a minimal standard basis of G with respect to order O.

 
The algorithm uses a normal form NF, for example sdm_nf_mora.
 The ground field is assumed to be K, and monomials ordered according
@@ -5880,7 +5880,7 @@ 
Groebner basis algorithmsPoly and public API functions.

 

 

-class sympy.polys.polyoptions.Options(gens, args, flags=None, strict=False)[source]

+class sympy.polys.polyoptions.Options(gens, args, flags=None, strict=False)[source]
 
Options manager for polynomial manipulation module.

 
Examples

 
>>> from sympy.polys.polyoptions import Options
@@ -5928,7 +5928,7 @@ 
Groebner basis algorithms
 

-clone(updates={})[source]

+clone(updates={})[source]
 
Clone self and update specified options.

 

 
@@ -5936,7 +5936,7 @@ 
Groebner basis algorithms
 

-sympy.polys.polyoptions.build_options(gens, args=None)[source]

+sympy.polys.polyoptions.build_options(gens, args=None)[source]
 
Construct options from keyword arguments or … options.

 

 
@@ -5946,7 +5946,7 @@ 
Groebner basis algorithms
 

-sympy.polys.polyconfig.setup(key, value=None)[source]

+sympy.polys.polyconfig.setup(key, value=None)[source]
 
Assign a value to (or reset) a configuration item.

 

 
@@ -5957,123 +5957,123 @@ 
Exceptions
 

-class sympy.polys.polyerrors.BasePolynomialError[source]

+class sympy.polys.polyerrors.BasePolynomialError[source]
 
Base class for polynomial related exceptions.

 

 
 

 

-class sympy.polys.polyerrors.ExactQuotientFailed(f, g, dom=None)[source]

+class sympy.polys.polyerrors.ExactQuotientFailed(f, g, dom=None)[source]
 

 
 

 

-class sympy.polys.polyerrors.OperationNotSupported(poly, func)[source]

+class sympy.polys.polyerrors.OperationNotSupported(poly, func)[source]
 

 
 

 

-class sympy.polys.polyerrors.HeuristicGCDFailed[source]

+class sympy.polys.polyerrors.HeuristicGCDFailed[source]
 

 
 

 

-class sympy.polys.polyerrors.HomomorphismFailed[source]

+class sympy.polys.polyerrors.HomomorphismFailed[source]
 

 
 

 

-class sympy.polys.polyerrors.IsomorphismFailed[source]

+class sympy.polys.polyerrors.IsomorphismFailed[source]
 

 
 

 

-class sympy.polys.polyerrors.ExtraneousFactors[source]

+class sympy.polys.polyerrors.ExtraneousFactors[source]
 

 
 

 

-class sympy.polys.polyerrors.EvaluationFailed[source]

+class sympy.polys.polyerrors.EvaluationFailed[source]
 

 
 

 

-class sympy.polys.polyerrors.RefinementFailed[source]

+class sympy.polys.polyerrors.RefinementFailed[source]
 

 
 

 

-class sympy.polys.polyerrors.CoercionFailed[source]

+class sympy.polys.polyerrors.CoercionFailed[source]
 

 
 

 

-class sympy.polys.polyerrors.NotInvertible[source]

+class sympy.polys.polyerrors.NotInvertible[source]
 

 
 

 

-class sympy.polys.polyerrors.NotReversible[source]

+class sympy.polys.polyerrors.NotReversible[source]
 

 
 

 

-class sympy.polys.polyerrors.NotAlgebraic[source]

+class sympy.polys.polyerrors.NotAlgebraic[source]
 

 
 

 

-class sympy.polys.polyerrors.DomainError[source]

+class sympy.polys.polyerrors.DomainError[source]
 

 
 

 

-class sympy.polys.polyerrors.PolynomialError[source]

+class sympy.polys.polyerrors.PolynomialError[source]
 

 
 

 

-class sympy.polys.polyerrors.UnificationFailed[source]

+class sympy.polys.polyerrors.UnificationFailed[source]
 

 
 

 

-class sympy.polys.polyerrors.GeneratorsNeeded[source]

+class sympy.polys.polyerrors.GeneratorsNeeded[source]
 

 
 

 

-class sympy.polys.polyerrors.ComputationFailed(func, nargs, exc)[source]

+class sympy.polys.polyerrors.ComputationFailed(func, nargs, exc)[source]
 

 
 

 

-class sympy.polys.polyerrors.GeneratorsError[source]

+class sympy.polys.polyerrors.GeneratorsError[source]
 

 
 

 

-class sympy.polys.polyerrors.UnivariatePolynomialError[source]

+class sympy.polys.polyerrors.UnivariatePolynomialError[source]
 

 
 

 

-class sympy.polys.polyerrors.MultivariatePolynomialError[source]

+class sympy.polys.polyerrors.MultivariatePolynomialError[source]
 

 
 

 

-class sympy.polys.polyerrors.PolificationFailed(opt, origs, exprs, seq=False)[source]

+class sympy.polys.polyerrors.PolificationFailed(opt, origs, exprs, seq=False)[source]
 

 
 

 

-class sympy.polys.polyerrors.OptionError[source]

+class sympy.polys.polyerrors.OptionError[source]
 

 
 

 

-class sympy.polys.polyerrors.FlagError[source]

+class sympy.polys.polyerrors.FlagError[source]
 

 
 
@@ -6083,7 +6083,7 @@ 
Reference

 

 

-sympy.polys.modulargcd.modgcd_univariate(f, g)[source]

+sympy.polys.modulargcd.modgcd_univariate(f, g)[source]
 
Computes the GCD of two polynomials in \(\mathbb{Z}[x]\) using a modular
 algorithm.

 
The algorithm computes the GCD of two univariate integer polynomials
@@ -6163,7 +6163,7 @@ 
Modular GCD
 

-sympy.polys.modulargcd.modgcd_bivariate(f, g)[source]

+sympy.polys.modulargcd.modgcd_bivariate(f, g)[source]
 
Computes the GCD of two polynomials in \(\mathbb{Z}[x, y]\) using a
 modular algorithm.

 
The algorithm computes the GCD of two bivariate integer polynomials
@@ -6249,7 +6249,7 @@ 
Modular GCD
 

-sympy.polys.modulargcd.modgcd_multivariate(f, g)[source]

+sympy.polys.modulargcd.modgcd_multivariate(f, g)[source]
 
Compute the GCD of two polynomials in \(\mathbb{Z}[x_0, \ldots, x_{k-1}]\)
 using a modular algorithm.

 
The algorithm computes the GCD of two multivariate integer polynomials
@@ -6350,7 +6350,7 @@ 
Modular GCDcontbound,

 

 
-)[source]
+)[source]
 
Compute the GCD of two polynomials in
 \(\mathbb{Z}_p[x_0, \ldots, x_{k-1}]\).

 
The algorithm reduces the problem step by step by evaluating the
@@ -6407,7 +6407,7 @@ 
Modular GCD
 

-sympy.polys.modulargcd.func_field_modgcd(f, g)[source]

+sympy.polys.modulargcd.func_field_modgcd(f, g)[source]
 
Compute the GCD of two polynomials \(f\) and \(g\) in
 \(\mathbb Q(\alpha)[x_0, \ldots, x_{n-1}]\) using a modular algorithm.

 
The algorithm first computes the primitive associate
diff --git a/dev/modules/polys/numberfields.html b/dev/modules/polys/numberfields.html
index ddaaed9b731..c0d1664adee 100644
--- a/dev/modules/polys/numberfields.html
+++ b/dev/modules/polys/numberfields.html
@@ -923,7 +923,7 @@ 
Solving the Main Problems

 

 

-sympy.polys.numberfields.basis.round_two(T, radicals=None)[source]

+sympy.polys.numberfields.basis.round_two(T, radicals=None)[source]
 
Zassenhaus’s “Round 2” algorithm.

 

 
Parameters:

@@ -1025,7 +1025,7 @@ 
Prime Decompositionradical=None,

 

 
-)[source]
+)[source]
 
Compute the decomposition of rational prime p in a number field.

 

 
Parameters:

@@ -1082,11 +1082,11 @@ 
Prime Decomposition
 

-class sympy.polys.numberfields.primes.PrimeIdeal(ZK, p, alpha, f, e=None)[source]

+class sympy.polys.numberfields.primes.PrimeIdeal(ZK, p, alpha, f, e=None)[source]
 
A prime ideal in a ring of algebraic integers.

 

 

-__init__(ZK, p, alpha, f, e=None)[source]

+__init__(ZK, p, alpha, f, e=None)[source]
 

 
Parameters:

 
ZK : Submodule

@@ -1116,7 +1116,7 @@ 
Prime Decomposition
 

-__add__(other)[source]

+__add__(other)[source]
 
Convert to a Submodule and add to another
 Submodule.

 

@@ -1127,7 +1127,7 @@ 
Prime Decomposition
 

-__mul__(other)[source]

+__mul__(other)[source]
 
Convert to a Submodule and multiply by another
 Submodule or a rational number.

 

@@ -1138,7 +1138,7 @@ 
Prime Decomposition
 

-as_submodule()[source]

+as_submodule()[source]
 
Represent this prime ideal as a Submodule.

 

 
Returns:

@@ -1194,7 +1194,7 @@ 
Prime Decomposition
 

-reduce_ANP(a)[source]

+reduce_ANP(a)[source]
 
Reduce an ANP to a “small representative” modulo this
 prime ideal.

 

@@ -1219,7 +1219,7 @@ 
Prime Decomposition
 

-reduce_alg_num(a)[source]

+reduce_alg_num(a)[source]
 
Reduce an AlgebraicNumber to a “small representative”
 modulo this prime ideal.

 

@@ -1244,7 +1244,7 @@ 
Prime Decomposition
 

-reduce_element(elt)[source]

+reduce_element(elt)[source]
 
Reduce a PowerBasisElement to a “small representative”
 modulo this prime ideal.

 

@@ -1269,7 +1269,7 @@ 
Prime Decomposition
 

-repr(field_gen=None, just_gens=False)[source]

+repr(field_gen=None, just_gens=False)[source]
 
Print a representation of this prime ideal.

 

 
Parameters:

@@ -1306,7 +1306,7 @@ 
Prime Decomposition
 

-test_factor()[source]

+test_factor()[source]
 
Compute a test factor for this prime ideal.

 
Explanation

 
Write \(\mathfrak{p}\) for this prime ideal, \(p\) for the rational prime
@@ -1320,7 +1320,7 @@ 
Prime Decomposition
 

-valuation(I)[source]

+valuation(I)[source]
 
Compute the \(\mathfrak{p}\)-adic valuation of integral ideal I at this
 prime ideal.

 

@@ -1341,7 +1341,7 @@ 
Prime Decomposition

 

 

-sympy.polys.numberfields.primes.prime_valuation(I, P)[source]

+sympy.polys.numberfields.primes.prime_valuation(I, P)[source]
 
Compute the P-adic valuation for an integral ideal I.

 

 
Parameters:

@@ -1398,7 +1398,7 @@ 
Galois Groups**args,

 

 
-)[source]
+)[source]
 
Compute the Galois group for polynomials f up to degree 6.

 

 
Parameters:

@@ -1518,7 +1518,7 @@ 
Finding Minimal Polynomialsdomain=None,

 

 
-)[source]
+)[source]
 
Computes the minimal polynomial of an algebraic element.

 

 
Parameters:

@@ -1584,7 +1584,7 @@ 
Finding Minimal Polynomialsdomain=None,

 

 
-)[source]
+)[source]
 
This is a synonym for minimal_polynomial().

 

 
@@ -1622,7 +1622,7 @@ 
The Subfield Problem
 

 

-sympy.polys.numberfields.subfield.field_isomorphism(a, b, *, fast=True)[source]

+sympy.polys.numberfields.subfield.field_isomorphism(a, b, *, fast=True)[source]
 
Find an embedding of one number field into another.

 

 
Parameters:

@@ -1679,7 +1679,7 @@ 
The Subfield Problempolys=False,

 

 
-)[source]
+)[source]
 
Find a single generator for a number field given by several generators.

 

 
Parameters:

@@ -1774,7 +1774,7 @@ 
The Subfield Problemalias=None,

 

 
-)[source]
+)[source]
 
Express one algebraic number in the field generated by another.

 

 
Parameters:

@@ -2059,7 +2059,7 @@ 
Module HomomorphismsClass Reference

 

 

-class sympy.polys.numberfields.modules.Module[source]

+class sympy.polys.numberfields.modules.Module[source]
 
Generic finitely-generated module.

 
This is an abstract base class, and should not be instantiated directly.
 The two concrete subclasses are PowerBasis and
@@ -2072,7 +2072,7 @@ 
Class ReferencePowerBasis.

 

 

-__call__(spec, denom=1)[source]

+__call__(spec, denom=1)[source]
 
Generate a ModuleElement belonging to this module.

 

 
Parameters:

@@ -2116,7 +2116,7 @@ 
Class Reference
 

-ancestors(include_self=False)[source]

+ancestors(include_self=False)[source]
 
Return the list of ancestor modules of this module, from the
 foundational PowerBasis downward, optionally including
 self.

@@ -2128,14 +2128,14 @@ 
Class Reference
 

-basis_elements()[source]

+basis_elements()[source]
 
Get list of ModuleElement being the generators of this
 module.

 

 
 

 

-element_from_rational(a)[source]

+element_from_rational(a)[source]
 
Return a ModuleElement representing a rational number.

 

 
Parameters:

@@ -2163,19 +2163,19 @@ 
Class Reference
 

-endomorphism_ring()[source]

+endomorphism_ring()[source]
 
Form the EndomorphismRing for this module.

 

 
 

 

-is_compat_col(col)[source]

+is_compat_col(col)[source]
 
Say whether col is a suitable column vector for this module.

 

 
 

 

-mult_tab()[source]

+mult_tab()[source]
 
Get the multiplication table for this module (if closed under mult).

 

 
Returns:

@@ -2218,7 +2218,7 @@ 
Class Reference
 

-nearest_common_ancestor(other)[source]

+nearest_common_ancestor(other)[source]
 
Locate the nearest common ancestor of this module and another.

 

 
Returns:

@@ -2250,7 +2250,7 @@ 
Class Reference
 

-one()[source]

+one()[source]
 
Return a ModuleElement representing unity,
 and belonging to the first ancestor of this module (including
 itself) that starts with unity.

@@ -2276,7 +2276,7 @@ 
Class Reference
 

-power_basis_ancestor()[source]

+power_basis_ancestor()[source]
 
Return the PowerBasis that is an ancestor of this module.

 

 
See also

@@ -2286,7 +2286,7 @@ 
Class Reference
 

-represent(elt)[source]

+represent(elt)[source]
 
Represent a module element as an integer-linear combination over the
 generators of this module.

 

@@ -2367,7 +2367,7 @@ 
Class Reference
 

-starts_with_unity()[source]

+starts_with_unity()[source]
 
Say whether the module’s first generator equals unity.

 

 
@@ -2381,7 +2381,7 @@ 
Class Referencehnf_modulus=None,

 

 
-)[source]
+)[source]
 
Form the submodule generated by a list of ModuleElement
 belonging to this module.

 

@@ -2421,7 +2421,7 @@ 
Class Reference
 

-submodule_from_matrix(B, denom=1)[source]

+submodule_from_matrix(B, denom=1)[source]
 
Form the submodule generated by the elements of this module indicated
 by the columns of a matrix, with an optional denominator.

 

@@ -2470,7 +2470,7 @@ 
Class Reference
 

-whole_submodule()[source]

+whole_submodule()[source]
 
Return a submodule equal to this entire module.

 
Explanation

 
This is useful when you have a PowerBasis and want to
@@ -2480,7 +2480,7 @@ 
Class Reference
 

-zero()[source]

+zero()[source]
 
Return a ModuleElement representing zero.

 

 
@@ -2488,11 +2488,11 @@ 
Class Reference
 

-class sympy.polys.numberfields.modules.PowerBasis(T)[source]

+class sympy.polys.numberfields.modules.PowerBasis(T)[source]
 
The module generated by the powers of an algebraic integer.

 

 

-__init__(T)[source]

+__init__(T)[source]
 

 
Parameters:

 
T : Poly, AlgebraicField

@@ -2508,19 +2508,19 @@ 
Class Reference
 

-element_from_ANP(a)[source]

+element_from_ANP(a)[source]
 
Convert an ANP into a PowerBasisElement.

 

 
 

 

-element_from_alg_num(a)[source]

+element_from_alg_num(a)[source]
 
Convert an AlgebraicNumber into a PowerBasisElement.

 

 
 

 

-element_from_poly(f)[source]

+element_from_poly(f)[source]
 
Produce an element of this module, representing f after reduction mod
 our defining minimal polynomial.

 

@@ -2535,7 +2535,7 @@ 
Class Reference
 

-represent(elt)[source]

+represent(elt)[source]
 
Represent a module element as an integer-linear combination over the
 generators of this module.

 

@@ -2548,7 +2548,7 @@ 
Class Reference
 

-class sympy.polys.numberfields.modules.Submodule(parent, matrix, denom=1, mult_tab=None)[source]

+class sympy.polys.numberfields.modules.Submodule(parent, matrix, denom=1, mult_tab=None)[source]
 
A submodule of another module.

 

 

@@ -2561,7 +2561,7 @@ 
Class Referencemult_tab=None,

 

 
-)[source]
+)[source]
 

 
Parameters:

 
parent : Module

@@ -2618,7 +2618,7 @@ 
Class Reference
 

-add(other, hnf=True, hnf_modulus=None)[source]

+add(other, hnf=True, hnf_modulus=None)[source]
 
Add this Submodule to another.

 

 
Parameters:

@@ -2646,21 +2646,21 @@ 
Class Reference
 

-basis_element_pullbacks()[source]

+basis_element_pullbacks()[source]
 
Return list of this submodule’s basis elements as elements of the
 submodule’s parent module.

 

 
 

 

-discard_before(r)[source]

+discard_before(r)[source]
 
Produce a new module by discarding all generators before a given
 index r.

 

 
 

 

-mul(other, hnf=True, hnf_modulus=None)[source]

+mul(other, hnf=True, hnf_modulus=None)[source]
 
Multiply this Submodule by a rational number, a
 ModuleElement, or another Submodule.

 

@@ -2693,7 +2693,7 @@ 
Class Reference
 

-reduce_element(elt)[source]

+reduce_element(elt)[source]
 
If this submodule \(B\) has defining matrix \(W\) in square, maximal-rank
 Hermite normal form, then, given an element \(x\) of the parent module
 \(A\), we produce an element \(y \in A\) such that \(x - y \in B\), and the
@@ -2756,7 +2756,7 @@ 
Class Reference
 

-reduced()[source]

+reduced()[source]
 
Produce a reduced version of this submodule.

 

 
Returns:

@@ -2771,7 +2771,7 @@ 
Class Reference
 

-represent(elt)[source]

+represent(elt)[source]
 
Represent a module element as an integer-linear combination over the
 generators of this module.

 

@@ -2784,14 +2784,14 @@ 
Class Reference
 

-class sympy.polys.numberfields.modules.ModuleElement(module, col, denom=1)[source]

+class sympy.polys.numberfields.modules.ModuleElement(module, col, denom=1)[source]
 
Represents an element of a Module.

 
NOTE: Should not be constructed directly. Use the
 __call__() method or the make_mod_elt()
 factory function instead.

 

 

-__init__(module, col, denom=1)[source]

+__init__(module, col, denom=1)[source]
 

 
Parameters:

 
module : Module

@@ -2813,7 +2813,7 @@ 
Class Reference
 

-__add__(other)[source]

+__add__(other)[source]
 
A ModuleElement can be added to a rational number, or to
 another ModuleElement.

 
Explanation

@@ -2827,7 +2827,7 @@ 
Class Reference
 

-__mul__(other)[source]

+__mul__(other)[source]
 
A ModuleElement can be multiplied by a rational number,
 or by another ModuleElement.

 
Explanation

@@ -2843,7 +2843,7 @@ 
Class Reference
 

-__mod__(m)[source]

+__mod__(m)[source]
 
Reduce this ModuleElement mod a Submodule.

 

 
Parameters:

@@ -2874,13 +2874,13 @@ 
Class Reference
 

-column(domain=None)[source]

+column(domain=None)[source]
 
Get a copy of this element’s column, optionally converting to a domain.

 

 
 

 

-equiv(other)[source]

+equiv(other)[source]
 
A ModuleElement may test as equivalent to a rational
 number or another ModuleElement, if they represent the
 same algebraic number.

@@ -2918,14 +2918,14 @@ 
Class Referencedenom=1,

 

 
-)[source]
+)[source]
 
Make a ModuleElement from a list of ints (instead of a
 column vector).

 

 
 

 

-is_compat(other)[source]

+is_compat(other)[source]
 
Test whether other is another ModuleElement with same
 module.

 

@@ -2938,28 +2938,28 @@ 
Class Reference
 

-over_power_basis()[source]

+over_power_basis()[source]
 
Transform into a PowerBasisElement over our
 PowerBasis ancestor.

 

 
 

 

-reduced()[source]

+reduced()[source]
 
Produce a reduced version of this ModuleElement, i.e. one in which the
 gcd of the denominator together with all numerator coefficients is 1.

 

 
 

 

-reduced_mod_p(p)[source]

+reduced_mod_p(p)[source]
 
Produce a version of this ModuleElement in which all
 numerator coefficients have been reduced mod p.

 

 
 

 

-to_ancestor(anc)[source]

+to_ancestor(anc)[source]
 
Transform into a ModuleElement belonging to a given
 ancestor of this element’s module.

 

@@ -2971,14 +2971,14 @@ 
Class Reference
 

-to_parent()[source]

+to_parent()[source]
 
Transform into a ModuleElement belonging to the parent of
 this element’s module.

 

 
 

 

-unify(other)[source]

+unify(other)[source]
 
Try to make a compatible pair of ModuleElement, one
 equivalent to this one, and one equivalent to the other.

 

@@ -3006,7 +3006,7 @@ 
Class Reference
 

-class sympy.polys.numberfields.modules.PowerBasisElement(module, col, denom=1)[source]

+class sympy.polys.numberfields.modules.PowerBasisElement(module, col, denom=1)[source]
 
Subclass for ModuleElement instances whose module is a
 PowerBasis.

 

@@ -3017,7 +3017,7 @@ 
Class Reference
 

-as_expr(x=None)[source]

+as_expr(x=None)[source]
 
Create a Basic expression from self.

 

 
@@ -3039,31 +3039,31 @@ 
Class Reference
 

-norm(T=None)[source]

+norm(T=None)[source]
 
Compute the norm of this number.

 

 
 

 

-numerator(x=None)[source]

+numerator(x=None)[source]
 
Obtain the numerator as a polynomial over ZZ.

 

 
 

 

-poly(x=None)[source]

+poly(x=None)[source]
 
Obtain the number as a polynomial over QQ.

 

 
 

 

-to_ANP()[source]

+to_ANP()[source]
 
Convert to an equivalent ANP.

 

 
 

 

-to_alg_num()[source]

+to_alg_num()[source]
 
Try to convert to an equivalent AlgebraicNumber.

 

 
Returns:

@@ -3092,7 +3092,7 @@ 
Class Reference
 

-sympy.polys.numberfields.modules.make_mod_elt(module, col, denom=1)[source]

+sympy.polys.numberfields.modules.make_mod_elt(module, col, denom=1)[source]
 
Factory function which builds a ModuleElement, but ensures
 that it is a PowerBasisElement if the module is a
 PowerBasis.

@@ -3100,7 +3100,7 @@ 
Class Reference
 

-class sympy.polys.numberfields.modules.ModuleHomomorphism(domain, codomain, mapping)[source]

+class sympy.polys.numberfields.modules.ModuleHomomorphism(domain, codomain, mapping)[source]
 
A homomorphism from one module to another.

 

 

@@ -3112,7 +3112,7 @@ 
Class Referencemapping,

 

 
-)[source]
+)[source]
 

 
Parameters:

 
domain : Module

@@ -3146,7 +3146,7 @@ 
Class Reference
 

-kernel(modulus=None)[source]

+kernel(modulus=None)[source]
 
Compute a Submodule representing the kernel of this homomorphism.

 

 
Parameters:

@@ -3169,7 +3169,7 @@ 
Class Reference
 

-matrix(modulus=None)[source]

+matrix(modulus=None)[source]
 
Compute the matrix of this homomorphism.

 

 
Parameters:

@@ -3193,11 +3193,11 @@ 
Class Reference
 

-class sympy.polys.numberfields.modules.ModuleEndomorphism(domain, mapping)[source]

+class sympy.polys.numberfields.modules.ModuleEndomorphism(domain, mapping)[source]
 
A homomorphism from one module to itself.

 

 

-__init__(domain, mapping)[source]

+__init__(domain, mapping)[source]
 

 
Parameters:

 
domain : Module

@@ -3218,12 +3218,12 @@ 
Class Reference
 

-class sympy.polys.numberfields.modules.InnerEndomorphism(domain, multiplier)[source]

+class sympy.polys.numberfields.modules.InnerEndomorphism(domain, multiplier)[source]
 
An inner endomorphism on a module, i.e. the endomorphism corresponding to
 multiplication by a fixed element.

 

 

-__init__(domain, multiplier)[source]

+__init__(domain, multiplier)[source]
 

 
Parameters:

 
domain : Module

@@ -3242,11 +3242,11 @@ 
Class Reference
 

-class sympy.polys.numberfields.modules.EndomorphismRing(domain)[source]

+class sympy.polys.numberfields.modules.EndomorphismRing(domain)[source]
 
The ring of endomorphisms on a module.

 

 

-__init__(domain)[source]

+__init__(domain)[source]
 

 
Parameters:

 
domain : Module

@@ -3259,7 +3259,7 @@ 
Class Reference
 

-inner_endomorphism(multiplier)[source]

+inner_endomorphism(multiplier)[source]
 
Form an inner endomorphism belonging to this endomorphism ring.

 

 
Parameters:

@@ -3276,7 +3276,7 @@ 
Class Reference
 

-represent(element)[source]

+represent(element)[source]
 
Represent an element of this endomorphism ring, as a single column
 vector.

 

@@ -3358,7 +3358,7 @@ 
Class Reference
 

-sympy.polys.numberfields.modules.find_min_poly(alpha, domain, x=None, powers=None)[source]

+sympy.polys.numberfields.modules.find_min_poly(alpha, domain, x=None, powers=None)[source]
 
Find a polynomial of least degree (not necessarily irreducible) satisfied
 by an element of a finitely-generated ring with unity.

 

@@ -3434,7 +3434,7 @@ 
Class Reference

 

 

-sympy.polys.numberfields.utilities.is_rat(c)[source]

+sympy.polys.numberfields.utilities.is_rat(c)[source]
 
Test whether an argument is of an acceptable type to be used as a rational
 number.

 
Explanation

@@ -3447,7 +3447,7 @@ 
Utilities
 

-sympy.polys.numberfields.utilities.is_int(c)[source]

+sympy.polys.numberfields.utilities.is_int(c)[source]
 
Test whether an argument is of an acceptable type to be used as an integer.

 
Explanation

 
Returns True on any argument of type int or ZZ.

@@ -3459,7 +3459,7 @@ 
Utilities
 

-sympy.polys.numberfields.utilities.get_num_denom(c)[source]

+sympy.polys.numberfields.utilities.get_num_denom(c)[source]
 
Given any argument on which is_rat() is True, return the
 numerator and denominator of this number.

 

@@ -3470,7 +3470,7 @@ 
Utilities
 

-sympy.polys.numberfields.utilities.extract_fundamental_discriminant(a)[source]

+sympy.polys.numberfields.utilities.extract_fundamental_discriminant(a)[source]
 
Extract a fundamental discriminant from an integer a.

 

 
Parameters:

@@ -3519,7 +3519,7 @@ 
Utilities
 

-class sympy.polys.numberfields.utilities.AlgIntPowers(T, modulus=None)[source]

+class sympy.polys.numberfields.utilities.AlgIntPowers(T, modulus=None)[source]
 
Compute the powers of an algebraic integer.

 
Explanation

 
Given an algebraic integer \(\theta\) by its monic irreducible polynomial
@@ -3553,7 +3553,7 @@ 
Utilities
 

-__init__(T, modulus=None)[source]

+__init__(T, modulus=None)[source]
 

 
Parameters:

 
T : Poly

@@ -3573,7 +3573,7 @@ 
Utilities
 
+sympy.polys.numberfields.utilities.coeff_search(m, R)[source]
 
Generate coefficients for searching through polynomials.

 

 
Parameters:

@@ -3610,7 +3610,7 @@ 
Utilities
 

-sympy.polys.numberfields.utilities.supplement_a_subspace(M)[source]

+sympy.polys.numberfields.utilities.supplement_a_subspace(M)[source]
 
Extend a basis for a subspace to a basis for the whole space.

 

 
Parameters:

@@ -3676,7 +3676,7 @@ 
Utilities
 

-sympy.polys.numberfields.utilities.isolate(alg, eps=None, fast=False)[source]

+sympy.polys.numberfields.utilities.isolate(alg, eps=None, fast=False)[source]
 
Find a rational isolating interval for a real algebraic number.

 

 
Parameters:

diff --git a/dev/modules/polys/reference.html b/dev/modules/polys/reference.html
index e1aff41c4ce..321c345f52d 100644
--- a/dev/modules/polys/reference.html
+++ b/dev/modules/polys/reference.html
@@ -807,7 +807,7 @@ 
Documentation Version

 
Basic polynomial manipulation functions

 

 

-sympy.polys.polytools.poly(expr, *gens, **args)[source]

+sympy.polys.polytools.poly(expr, *gens, **args)[source]
 
Efficiently transform an expression into a polynomial.

 
Examples

 
>>> from sympy import poly
@@ -822,19 +822,19 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.poly_from_expr(expr, *gens, **args)[source]

+sympy.polys.polytools.poly_from_expr(expr, *gens, **args)[source]
 
Construct a polynomial from an expression.

 

 
 

 

-sympy.polys.polytools.parallel_poly_from_expr(exprs, *gens, **args)[source]

+sympy.polys.polytools.parallel_poly_from_expr(exprs, *gens, **args)[source]
 
Construct polynomials from expressions.

 

 
 

 

-sympy.polys.polytools.degree(f, gen=0)[source]

+sympy.polys.polytools.degree(f, gen=0)[source]
 
Return the degree of f in the given variable.

 
The degree of 0 is negative infinity.

 
Examples

@@ -858,7 +858,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.degree_list(f, *gens, **args)[source]

+sympy.polys.polytools.degree_list(f, *gens, **args)[source]
 
Return a list of degrees of f in all variables.

 
Examples

 
>>> from sympy import degree_list
@@ -873,7 +873,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.LC(f, *gens, **args)[source]

+sympy.polys.polytools.LC(f, *gens, **args)[source]
 
Return the leading coefficient of f.

 
Examples

 
>>> from sympy import LC
@@ -888,7 +888,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.LM(f, *gens, **args)[source]

+sympy.polys.polytools.LM(f, *gens, **args)[source]
 
Return the leading monomial of f.

 
Examples

 
>>> from sympy import LM
@@ -903,7 +903,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.LT(f, *gens, **args)[source]

+sympy.polys.polytools.LT(f, *gens, **args)[source]
 
Return the leading term of f.

 
Examples

 
>>> from sympy import LT
@@ -918,7 +918,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.pdiv(f, g, *gens, **args)[source]

+sympy.polys.polytools.pdiv(f, g, *gens, **args)[source]
 
Compute polynomial pseudo-division of f and g.

 
Examples

 
>>> from sympy import pdiv
@@ -933,7 +933,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.prem(f, g, *gens, **args)[source]

+sympy.polys.polytools.prem(f, g, *gens, **args)[source]
 
Compute polynomial pseudo-remainder of f and g.

 
Examples

 
>>> from sympy import prem
@@ -948,7 +948,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.pquo(f, g, *gens, **args)[source]

+sympy.polys.polytools.pquo(f, g, *gens, **args)[source]
 
Compute polynomial pseudo-quotient of f and g.

 
Examples

 
>>> from sympy import pquo
@@ -965,7 +965,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.pexquo(f, g, *gens, **args)[source]

+sympy.polys.polytools.pexquo(f, g, *gens, **args)[source]
 
Compute polynomial exact pseudo-quotient of f and g.

 
Examples

 
>>> from sympy import pexquo
@@ -986,7 +986,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.div(f, g, *gens, **args)[source]

+sympy.polys.polytools.div(f, g, *gens, **args)[source]
 
Compute polynomial division of f and g.

 
Examples

 
>>> from sympy import div, ZZ, QQ
@@ -1003,7 +1003,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.rem(f, g, *gens, **args)[source]

+sympy.polys.polytools.rem(f, g, *gens, **args)[source]
 
Compute polynomial remainder of f and g.

 
Examples

 
>>> from sympy import rem, ZZ, QQ
@@ -1020,7 +1020,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.quo(f, g, *gens, **args)[source]

+sympy.polys.polytools.quo(f, g, *gens, **args)[source]
 
Compute polynomial quotient of f and g.

 
Examples

 
>>> from sympy import quo
@@ -1037,7 +1037,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.exquo(f, g, *gens, **args)[source]

+sympy.polys.polytools.exquo(f, g, *gens, **args)[source]
 
Compute polynomial exact quotient of f and g.

 
Examples

 
>>> from sympy import exquo
@@ -1058,7 +1058,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.half_gcdex(f, g, *gens, **args)[source]

+sympy.polys.polytools.half_gcdex(f, g, *gens, **args)[source]
 
Half extended Euclidean algorithm of f and g.

 
Returns (s, h) such that h = gcd(f, g) and s*f = h (mod g).

 
Examples

@@ -1074,7 +1074,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.gcdex(f, g, *gens, **args)[source]

+sympy.polys.polytools.gcdex(f, g, *gens, **args)[source]
 
Extended Euclidean algorithm of f and g.

 
Returns (s, t, h) such that h = gcd(f, g) and s*f + t*g = h.

 
Examples

@@ -1090,7 +1090,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.invert(f, g, *gens, **args)[source]

+sympy.polys.polytools.invert(f, g, *gens, **args)[source]
 
Invert f modulo g when possible.

 
Examples

 
>>> from sympy import invert, S, mod_inverse
@@ -1123,7 +1123,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.subresultants(f, g, *gens, **args)[source]

+sympy.polys.polytools.subresultants(f, g, *gens, **args)[source]
 
Compute subresultant PRS of f and g.

 
Examples

 
>>> from sympy import subresultants
@@ -1138,7 +1138,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.resultant(f, g, *gens, includePRS=False, **args)[source]

+sympy.polys.polytools.resultant(f, g, *gens, includePRS=False, **args)[source]
 
Compute resultant of f and g.

 
Examples

 
>>> from sympy import resultant
@@ -1153,7 +1153,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.discriminant(f, *gens, **args)[source]

+sympy.polys.polytools.discriminant(f, *gens, **args)[source]
 
Compute discriminant of f.

 
Examples

 
>>> from sympy import discriminant
@@ -1168,7 +1168,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.terms_gcd(f, *gens, **args)[source]

+sympy.polys.polytools.terms_gcd(f, *gens, **args)[source]
 
Remove GCD of terms from f.

 
If the deep flag is True, then the arguments of f will have
 terms_gcd applied to them.

@@ -1231,7 +1231,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.cofactors(f, g, *gens, **args)[source]

+sympy.polys.polytools.cofactors(f, g, *gens, **args)[source]
 
Compute GCD and cofactors of f and g.

 
Returns polynomials (h, cff, cfg) such that h = gcd(f, g), and
 cff = quo(f, h) and cfg = quo(g, h) are, so called, cofactors
@@ -1249,7 +1249,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.gcd(f, g=None, *gens, **args)[source]

+sympy.polys.polytools.gcd(f, g=None, *gens, **args)[source]
 
Compute GCD of f and g.

 
Examples

 
>>> from sympy import gcd
@@ -1264,7 +1264,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.gcd_list(seq, *gens, **args)[source]

+sympy.polys.polytools.gcd_list(seq, *gens, **args)[source]
 
Compute GCD of a list of polynomials.

 
Examples

 
>>> from sympy import gcd_list
@@ -1279,7 +1279,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.lcm(f, g=None, *gens, **args)[source]

+sympy.polys.polytools.lcm(f, g=None, *gens, **args)[source]
 
Compute LCM of f and g.

 
Examples

 
>>> from sympy import lcm
@@ -1294,7 +1294,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.lcm_list(seq, *gens, **args)[source]

+sympy.polys.polytools.lcm_list(seq, *gens, **args)[source]
 
Compute LCM of a list of polynomials.

 
Examples

 
>>> from sympy import lcm_list
@@ -1309,7 +1309,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.trunc(f, p, *gens, **args)[source]

+sympy.polys.polytools.trunc(f, p, *gens, **args)[source]
 
Reduce f modulo a constant p.

 
Examples

 
>>> from sympy import trunc
@@ -1324,7 +1324,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.monic(f, *gens, **args)[source]

+sympy.polys.polytools.monic(f, *gens, **args)[source]
 
Divide all coefficients of f by LC(f).

 
Examples

 
>>> from sympy import monic
@@ -1339,7 +1339,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.content(f, *gens, **args)[source]

+sympy.polys.polytools.content(f, *gens, **args)[source]
 
Compute GCD of coefficients of f.

 
Examples

 
>>> from sympy import content
@@ -1354,7 +1354,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.primitive(f, *gens, **args)[source]

+sympy.polys.polytools.primitive(f, *gens, **args)[source]
 
Compute content and the primitive form of f.

 
Examples

 
>>> from sympy.polys.polytools import primitive
@@ -1388,7 +1388,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.compose(f, g, *gens, **args)[source]

+sympy.polys.polytools.compose(f, g, *gens, **args)[source]
 
Compute functional composition f(g).

 
Examples

 
>>> from sympy import compose
@@ -1403,7 +1403,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.decompose(f, *gens, **args)[source]

+sympy.polys.polytools.decompose(f, *gens, **args)[source]
 
Compute functional decomposition of f.

 
Examples

 
>>> from sympy import decompose
@@ -1418,7 +1418,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.sturm(f, *gens, **args)[source]

+sympy.polys.polytools.sturm(f, *gens, **args)[source]
 
Compute Sturm sequence of f.

 
Examples

 
>>> from sympy import sturm
@@ -1433,7 +1433,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.gff_list(f, *gens, **args)[source]

+sympy.polys.polytools.gff_list(f, *gens, **args)[source]
 
Compute a list of greatest factorial factors of f.

 
Note that the input to ff() and rf() should be Poly instances to use the
 definitions here.

@@ -1468,13 +1468,13 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.gff(f, *gens, **args)[source]

+sympy.polys.polytools.gff(f, *gens, **args)[source]
 
Compute greatest factorial factorization of f.

 

 
 

 

-sympy.polys.polytools.sqf_norm(f, *gens, **args)[source]

+sympy.polys.polytools.sqf_norm(f, *gens, **args)[source]
 
Compute square-free norm of f.

 
Returns s, f, r, such that g(x) = f(x-sa) and
 r(x) = Norm(g(x)) is a square-free polynomial over K,
@@ -1492,7 +1492,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.sqf_part(f, *gens, **args)[source]

+sympy.polys.polytools.sqf_part(f, *gens, **args)[source]
 
Compute square-free part of f.

 
Examples

 
>>> from sympy import sqf_part
@@ -1507,7 +1507,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.sqf_list(f, *gens, **args)[source]

+sympy.polys.polytools.sqf_list(f, *gens, **args)[source]
 
Compute a list of square-free factors of f.

 
Examples

 
>>> from sympy import sqf_list
@@ -1522,7 +1522,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.sqf(f, *gens, **args)[source]

+sympy.polys.polytools.sqf(f, *gens, **args)[source]
 
Compute square-free factorization of f.

 
Examples

 
>>> from sympy import sqf
@@ -1537,7 +1537,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.factor_list(f, *gens, **args)[source]

+sympy.polys.polytools.factor_list(f, *gens, **args)[source]
 
Compute a list of irreducible factors of f.

 
Examples

 
>>> from sympy import factor_list
@@ -1552,7 +1552,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.factor(f, *gens, deep=False, **args)[source]

+sympy.polys.polytools.factor(f, *gens, deep=False, **args)[source]
 
Compute the factorization of expression, f, into irreducibles. (To
 factor an integer into primes, use factorint.)

 
There two modes implemented: symbolic and formal. If f is not an
@@ -1633,7 +1633,7 @@ 
Basic polynomial manipulation functionssqf=False,

 

 
-)[source]
+)[source]
 
Compute isolating intervals for roots of f.

 
Examples

 
>>> from sympy import intervals
@@ -1662,7 +1662,7 @@ 
Basic polynomial manipulation functionscheck_sqf=False,

 

 
-)[source]
+)[source]
 
Refine an isolating interval of a root to the given precision.

 
Examples

 
>>> from sympy import refine_root
@@ -1677,7 +1677,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.count_roots(f, inf=None, sup=None)[source]

+sympy.polys.polytools.count_roots(f, inf=None, sup=None)[source]
 
Return the number of roots of f in [inf, sup] interval.

 
If one of inf or sup is complex, it will return the number of roots
 in the complex rectangle with corners at inf and sup.

@@ -1705,7 +1705,7 @@ 
Basic polynomial manipulation functionsextension=False,

 

 
-)[source]
+)[source]
 
Returns the real and complex roots of f with multiplicities.

 

 
Parameters:

@@ -1863,7 +1863,7 @@ 
Basic polynomial manipulation functionsextension=False,

 

 
-)[source]
+)[source]
 
Returns the real roots of f with multiplicities.

 

 
Parameters:

@@ -2034,7 +2034,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.nroots(f, n=15, maxsteps=50, cleanup=True)[source]

+sympy.polys.polytools.nroots(f, n=15, maxsteps=50, cleanup=True)[source]
 
Compute numerical approximations of roots of f.

 
Examples

 
>>> from sympy import nroots
@@ -2051,7 +2051,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.ground_roots(f, *gens, **args)[source]

+sympy.polys.polytools.ground_roots(f, *gens, **args)[source]
 
Compute roots of f by factorization in the ground domain.

 
Examples

 
>>> from sympy import ground_roots
@@ -2066,7 +2066,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.nth_power_roots_poly(f, n, *gens, **args)[source]

+sympy.polys.polytools.nth_power_roots_poly(f, n, *gens, **args)[source]
 
Construct a polynomial with n-th powers of roots of f.

 
Examples

 
>>> from sympy import nth_power_roots_poly, factor, roots
@@ -2093,7 +2093,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.cancel(f, *gens, _signsimp=True, **args)[source]

+sympy.polys.polytools.cancel(f, *gens, _signsimp=True, **args)[source]
 
Cancel common factors in a rational function f.

 
Examples

 
>>> from sympy import cancel, sqrt, Symbol, together
@@ -2119,7 +2119,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.reduced(f, G, *gens, **args)[source]

+sympy.polys.polytools.reduced(f, G, *gens, **args)[source]
 
Reduces a polynomial f modulo a set of polynomials G.

 
Given a polynomial f and a set of polynomials G = (g_1, ..., g_n),
 computes a set of quotients q = (q_1, ..., q_n) and the remainder r
@@ -2138,7 +2138,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.groebner(F, *gens, **args)[source]

+sympy.polys.polytools.groebner(F, *gens, **args)[source]
 
Computes the reduced Groebner basis for a set of polynomials.

 
Use the order argument to set the monomial ordering that will be
 used to compute the basis. Allowed orders are lex, grlex and
@@ -2187,7 +2187,7 @@ 
Basic polynomial manipulation functions
 

-sympy.polys.polytools.is_zero_dimensional(F, *gens, **args)[source]

+sympy.polys.polytools.is_zero_dimensional(F, *gens, **args)[source]
 
Checks if the ideal generated by a Groebner basis is zero-dimensional.

 
The algorithm checks if the set of monomials not divisible by the
 leading monomial of any element of F is bounded.

@@ -2198,7 +2198,7 @@ 
Basic polynomial manipulation functions
 

-class sympy.polys.polytools.Poly(rep, *gens, **args)[source]

+class sympy.polys.polytools.Poly(rep, *gens, **args)[source]
 
Generic class for representing and operating on polynomial expressions.

 
See Polynomial Manipulation for general documentation.

 
Poly is a subclass of Basic rather than Expr but instances can be
@@ -2245,7 +2245,7 @@ 
Basic polynomial manipulation functions
 

-EC(order=None)[source]

+EC(order=None)[source]
 
Returns the last non-zero coefficient of f.

 
Examples

 
>>> from sympy import Poly
@@ -2260,7 +2260,7 @@ 
Basic polynomial manipulation functions
 

-EM(order=None)[source]

+EM(order=None)[source]
 
Returns the last non-zero monomial of f.

 
Examples

 
>>> from sympy import Poly
@@ -2275,7 +2275,7 @@ 
Basic polynomial manipulation functions
 

-ET(order=None)[source]

+ET(order=None)[source]
 
Returns the last non-zero term of f.

 
Examples

 
>>> from sympy import Poly
@@ -2290,7 +2290,7 @@ 
Basic polynomial manipulation functions
 

-LC(order=None)[source]

+LC(order=None)[source]
 
Returns the leading coefficient of f.

 
Examples

 
>>> from sympy import Poly
@@ -2305,7 +2305,7 @@ 
Basic polynomial manipulation functions
 

-LM(order=None)[source]

+LM(order=None)[source]
 
Returns the leading monomial of f.

 
The Leading monomial signifies the monomial having
 the highest power of the principal generator in the
@@ -2323,7 +2323,7 @@ 
Basic polynomial manipulation functions
 

-LT(order=None)[source]

+LT(order=None)[source]
 
Returns the leading term of f.

 
The Leading term signifies the term having
 the highest power of the principal generator in the
@@ -2341,7 +2341,7 @@ 
Basic polynomial manipulation functions
 

-TC()[source]

+TC()[source]
 
Returns the trailing coefficient of f.

 
Examples

 
>>> from sympy import Poly
@@ -2356,7 +2356,7 @@ 
Basic polynomial manipulation functions
 

-abs()[source]

+abs()[source]
 
Make all coefficients in f positive.

 
Examples

 
>>> from sympy import Poly
@@ -2371,7 +2371,7 @@ 
Basic polynomial manipulation functions
 

-add(g)[source]

+add(g)[source]
 
Add two polynomials f and g.

 
Examples

 
>>> from sympy import Poly
@@ -2390,7 +2390,7 @@ 
Basic polynomial manipulation functions
 

-add_ground(coeff)[source]

+add_ground(coeff)[source]
 
Add an element of the ground domain to f.

 
Examples

 
>>> from sympy import Poly
@@ -2405,7 +2405,7 @@ 
Basic polynomial manipulation functions
 

-all_coeffs()[source]

+all_coeffs()[source]
 
Returns all coefficients from a univariate polynomial f.

 
Examples

 
>>> from sympy import Poly
@@ -2420,7 +2420,7 @@ 
Basic polynomial manipulation functions
 

-all_monoms()[source]

+all_monoms()[source]
 
Returns all monomials from a univariate polynomial f.

 
Examples

 
>>> from sympy import Poly
@@ -2439,7 +2439,7 @@ 
Basic polynomial manipulation functions
 

-all_roots(multiple=True, radicals=True)[source]

+all_roots(multiple=True, radicals=True)[source]
 
Return a list of real and complex roots with multiplicities.

 
See all_roots() for more explanation.

 
Examples

@@ -2459,7 +2459,7 @@ 
Basic polynomial manipulation functions
 

-all_terms()[source]

+all_terms()[source]
 
Returns all terms from a univariate polynomial f.

 
Examples

 
>>> from sympy import Poly
@@ -2474,7 +2474,7 @@ 
Basic polynomial manipulation functions
 

-as_dict(native=False, zero=False)[source]

+as_dict(native=False, zero=False)[source]
 
Switch to a dict representation.

 
Examples

 
>>> from sympy import Poly
@@ -2489,7 +2489,7 @@ 
Basic polynomial manipulation functions
 

-as_expr(*gens)[source]

+as_expr(*gens)[source]
 
Convert a Poly instance to an Expr instance.

 
Examples

 
>>> from sympy import Poly
@@ -2511,13 +2511,13 @@ 
Basic polynomial manipulation functions
 

-as_list(native=False)[source]

+as_list(native=False)[source]
 
Switch to a list representation.

 

 
 

 

-as_poly(*gens, **args)[source]

+as_poly(*gens, **args)[source]
 
Converts self to a polynomial or returns None.

 
>>> from sympy import sin
 >>> from sympy.abc import x, y
@@ -2539,7 +2539,7 @@ 
Basic polynomial manipulation functions
 

-cancel(g, include=False)[source]

+cancel(g, include=False)[source]
 
Cancel common factors in a rational function f/g.

 
Examples

 
>>> from sympy import Poly
@@ -2558,7 +2558,7 @@ 
Basic polynomial manipulation functions
 

-clear_denoms(convert=False)[source]

+clear_denoms(convert=False)[source]
 
Clear denominators, but keep the ground domain.

 
Examples

 
>>> from sympy import Poly, S, QQ
@@ -2578,7 +2578,7 @@ 
Basic polynomial manipulation functions
 

-coeff_monomial(monom)[source]

+coeff_monomial(monom)[source]
 
Returns the coefficient of monom in f if there, else None.

 
Examples

 
>>> from sympy import Poly, exp
@@ -2618,7 +2618,7 @@ 
Basic polynomial manipulation functions
 

-coeffs(order=None)[source]

+coeffs(order=None)[source]
 
Returns all non-zero coefficients from f in lex order.

 
Examples

 
>>> from sympy import Poly
@@ -2637,7 +2637,7 @@ 
Basic polynomial manipulation functions
 

-cofactors(g)[source]

+cofactors(g)[source]
 
Returns the GCD of f and g and their cofactors.

 
Returns polynomials (h, cff, cfg) such that h = gcd(f, g), and
 cff = quo(f, h) and cfg = quo(g, h) are, so called, cofactors
@@ -2657,7 +2657,7 @@ 
Basic polynomial manipulation functions
 

-compose(g)[source]

+compose(g)[source]
 
Computes the functional composition of f and g.

 
Examples

 
>>> from sympy import Poly
@@ -2672,7 +2672,7 @@ 
Basic polynomial manipulation functions
 

-content()[source]

+content()[source]
 
Returns the GCD of polynomial coefficients.

 
Examples

 
>>> from sympy import Poly
@@ -2687,7 +2687,7 @@ 
Basic polynomial manipulation functions
 

-count_roots(inf=None, sup=None)[source]

+count_roots(inf=None, sup=None)[source]
 
Return the number of roots of f in [inf, sup] interval.

 
Examples

 
>>> from sympy import Poly, I
@@ -2704,7 +2704,7 @@ 
Basic polynomial manipulation functions
 

-decompose()[source]

+decompose()[source]
 
Computes a functional decomposition of f.

 
Examples

 
>>> from sympy import Poly
@@ -2719,7 +2719,7 @@ 
Basic polynomial manipulation functions
 

-deflate()[source]

+deflate()[source]
 
Reduce degree of f by mapping x_i**m to y_i.

 
Examples

 
>>> from sympy import Poly
@@ -2734,7 +2734,7 @@ 
Basic polynomial manipulation functions
 

-degree(gen=0)[source]

+degree(gen=0)[source]
 
Returns degree of f in x_j.

 
The degree of 0 is negative infinity.

 
Examples

@@ -2754,7 +2754,7 @@ 
Basic polynomial manipulation functions
 

-degree_list()[source]

+degree_list()[source]
 
Returns a list of degrees of f.

 
Examples

 
>>> from sympy import Poly
@@ -2769,7 +2769,7 @@ 
Basic polynomial manipulation functions
 

-diff(*specs, **kwargs)[source]

+diff(*specs, **kwargs)[source]
 
Computes partial derivative of f.

 
Examples

 
>>> from sympy import Poly
@@ -2788,7 +2788,7 @@ 
Basic polynomial manipulation functions
 

-discriminant()[source]

+discriminant()[source]
 
Computes the discriminant of f.

 
Examples

 
>>> from sympy import Poly
@@ -2803,7 +2803,7 @@ 
Basic polynomial manipulation functions
 

-dispersion(g=None)[source]

+dispersion(g=None)[source]
 
Compute the dispersion of polynomials.

 
For two polynomials \(f(x)\) and \(g(x)\) with \(\deg f > 0\)
 and \(\deg g > 0\) the dispersion \(\operatorname{dis}(f, g)\) is defined as:

@@ -2874,7 +2874,7 @@ 
Basic polynomial manipulation functions
 

-dispersionset(g=None)[source]

+dispersionset(g=None)[source]
 
Compute the dispersion set of two polynomials.

 
For two polynomials \(f(x)\) and \(g(x)\) with \(\deg f > 0\)
 and \(\deg g > 0\) the dispersion set \(\operatorname{J}(f, g)\) is defined as:

@@ -2945,7 +2945,7 @@ 
Basic polynomial manipulation functions
 

-div(g, auto=True)[source]

+div(g, auto=True)[source]
 
Polynomial division with remainder of f by g.

 
Examples

 
>>> from sympy import Poly
@@ -2988,7 +2988,7 @@ 
Basic polynomial manipulation functions
 

-eject(*gens)[source]

+eject(*gens)[source]
 
Eject selected generators into the ground domain.

 
Examples

 
>>> from sympy import Poly
@@ -3008,7 +3008,7 @@ 
Basic polynomial manipulation functions
 

-eval(x, a=None, auto=True)[source]

+eval(x, a=None, auto=True)[source]
 
Evaluate f at a in the given variable.

 
Examples

 
>>> from sympy import Poly
@@ -3044,7 +3044,7 @@ 
Basic polynomial manipulation functions
 

-exclude()[source]

+exclude()[source]
 
Remove unnecessary generators from f.

 
Examples

 
>>> from sympy import Poly
@@ -3059,7 +3059,7 @@ 
Basic polynomial manipulation functions
 

-exquo(g, auto=True)[source]

+exquo(g, auto=True)[source]
 
Computes polynomial exact quotient of f by g.

 
Examples

 
>>> from sympy import Poly
@@ -3080,7 +3080,7 @@ 
Basic polynomial manipulation functions
 

-exquo_ground(coeff)[source]

+exquo_ground(coeff)[source]
 
Exact quotient of f by a an element of the ground domain.

 
Examples

 
>>> from sympy import Poly
@@ -3101,7 +3101,7 @@ 
Basic polynomial manipulation functions
 

-factor_list()[source]

+factor_list()[source]
 
Returns a list of irreducible factors of f.

 
Examples

 
>>> from sympy import Poly
@@ -3120,7 +3120,7 @@ 
Basic polynomial manipulation functions
 

-factor_list_include()[source]

+factor_list_include()[source]
 
Returns a list of irreducible factors of f.

 
Examples

 
>>> from sympy import Poly
@@ -3179,25 +3179,25 @@ 
Basic polynomial manipulation functions
 

-classmethod from_dict(rep, *gens, **args)[source]

+classmethod from_dict(rep, *gens, **args)[source]
 
Construct a polynomial from a dict.

 

 
 

 

-classmethod from_expr(rep, *gens, **args)[source]

+classmethod from_expr(rep, *gens, **args)[source]
 
Construct a polynomial from an expression.

 

 
 

 

-classmethod from_list(rep, *gens, **args)[source]

+classmethod from_list(rep, *gens, **args)[source]
 
Construct a polynomial from a list.

 

 
 

 

-classmethod from_poly(rep, *gens, **args)[source]

+classmethod from_poly(rep, *gens, **args)[source]
 
Construct a polynomial from a polynomial.

 

 
@@ -3211,7 +3211,7 @@ 
Basic polynomial manipulation functionsrandomize=False,

 

 
-)[source]
+)[source]
 
Compute the Galois group of this polynomial.

 
Examples

 
>>> from sympy import Poly
@@ -3230,7 +3230,7 @@ 
Basic polynomial manipulation functions
 

-gcd(g)[source]

+gcd(g)[source]
 
Returns the polynomial GCD of f and g.

 
Examples

 
>>> from sympy import Poly
@@ -3245,7 +3245,7 @@ 
Basic polynomial manipulation functions
 

-gcdex(g, auto=True)[source]

+gcdex(g, auto=True)[source]
 
Extended Euclidean algorithm of f and g.

 
Returns (s, t, h) such that h = gcd(f, g) and s*f + t*g = h.

 
Examples

@@ -3282,13 +3282,13 @@ 
Basic polynomial manipulation functions
 

-get_domain()[source]

+get_domain()[source]
 
Get the ground domain of f.

 

 
 

 

-get_modulus()[source]

+get_modulus()[source]
 
Get the modulus of f.

 
Examples

 
>>> from sympy import Poly
@@ -3303,7 +3303,7 @@ 
Basic polynomial manipulation functions
 

-gff_list()[source]

+gff_list()[source]
 
Computes greatest factorial factorization of f.

 
Examples

 
>>> from sympy import Poly
@@ -3321,7 +3321,7 @@ 
Basic polynomial manipulation functions
 

-ground_roots()[source]

+ground_roots()[source]
 
Compute roots of f by factorization in the ground domain.

 
Examples

 
>>> from sympy import Poly
@@ -3336,7 +3336,7 @@ 
Basic polynomial manipulation functions
 

-half_gcdex(g, auto=True)[source]

+half_gcdex(g, auto=True)[source]
 
Half extended Euclidean algorithm of f and g.

 
Returns (s, h) such that h = gcd(f, g) and s*f = h (mod g).

 
Examples

@@ -3356,7 +3356,7 @@ 
Basic polynomial manipulation functions
 

-has_only_gens(*gens)[source]

+has_only_gens(*gens)[source]
 
Return True if Poly(f, *gens) retains ground domain.

 
Examples

 
>>> from sympy import Poly
@@ -3373,7 +3373,7 @@ 
Basic polynomial manipulation functions
 

-homogeneous_order()[source]

+homogeneous_order()[source]
 
Returns the homogeneous order of f.

 
A homogeneous polynomial is a polynomial whose all monomials with
 non-zero coefficients have the same total degree. This degree is
@@ -3393,7 +3393,7 @@ 
Basic polynomial manipulation functions
 

-homogenize(s)[source]

+homogenize(s)[source]
 
Returns the homogeneous polynomial of f.

 
A homogeneous polynomial is a polynomial whose all monomials with
 non-zero coefficients have the same total degree. If you only
@@ -3415,7 +3415,7 @@ 
Basic polynomial manipulation functions
 

-inject(front=False)[source]

+inject(front=False)[source]
 
Inject ground domain generators into f.

 
Examples

 
>>> from sympy import Poly
@@ -3435,7 +3435,7 @@ 
Basic polynomial manipulation functions
 

-integrate(*specs, **args)[source]

+integrate(*specs, **args)[source]
 
Computes indefinite integral of f.

 
Examples

 
>>> from sympy import Poly
@@ -3465,7 +3465,7 @@ 
Basic polynomial manipulation functionssqf=False,

 

 
-)[source]
+)[source]
 
Compute isolating intervals for roots of f.

 
For real roots the Vincent-Akritas-Strzebonski (VAS) continued fractions method is used.

 
Examples

@@ -3497,7 +3497,7 @@ 
Basic polynomial manipulation functions
 

-invert(g, auto=True)[source]

+invert(g, auto=True)[source]
 
Invert f modulo g when possible.

 
Examples

 
>>> from sympy import Poly
@@ -3778,7 +3778,7 @@ 
Basic polynomial manipulation functions
 

-l1_norm()[source]

+l1_norm()[source]
 
Returns l1 norm of f.

 
Examples

 
>>> from sympy import Poly
@@ -3793,7 +3793,7 @@ 
Basic polynomial manipulation functions
 

-lcm(g)[source]

+lcm(g)[source]
 
Returns polynomial LCM of f and g.

 
Examples

 
>>> from sympy import Poly
@@ -3808,7 +3808,7 @@ 
Basic polynomial manipulation functions
 

-length()[source]

+length()[source]
 
Returns the number of non-zero terms in f.

 
Examples

 
>>> from sympy import Poly
@@ -3823,7 +3823,7 @@ 
Basic polynomial manipulation functions
 

-lift()[source]

+lift()[source]
 
Convert algebraic coefficients to rationals.

 
Examples

 
>>> from sympy import Poly, I
@@ -3838,7 +3838,7 @@ 
Basic polynomial manipulation functions
 

-ltrim(gen)[source]

+ltrim(gen)[source]
 
Remove dummy generators from f that are to the left of
 specified gen in the generators as ordered. When gen
 is an integer, it refers to the generator located at that
@@ -3858,7 +3858,7 @@ 
Basic polynomial manipulation functions
 

-make_monic_over_integers_by_scaling_roots()[source]

+make_monic_over_integers_by_scaling_roots()[source]
 
Turn any univariate polynomial over QQ or ZZ into a monic
 polynomial over ZZ, by scaling the roots as necessary.

 

@@ -3886,13 +3886,13 @@ 
Basic polynomial manipulation functions
 

-match(*args, **kwargs)[source]

+match(*args, **kwargs)[source]
 
Match expression from Poly. See Basic.match()

 

 
 

 

-max_norm()[source]

+max_norm()[source]
 
Returns maximum norm of f.

 
Examples

 
>>> from sympy import Poly
@@ -3907,7 +3907,7 @@ 
Basic polynomial manipulation functions
 

-monic(auto=True)[source]

+monic(auto=True)[source]
 
Divides all coefficients by LC(f).

 
Examples

 
>>> from sympy import Poly, ZZ
@@ -3926,7 +3926,7 @@ 
Basic polynomial manipulation functions
 

-monoms(order=None)[source]

+monoms(order=None)[source]
 
Returns all non-zero monomials from f in lex order.

 
Examples

 
>>> from sympy import Poly
@@ -3945,7 +3945,7 @@ 
Basic polynomial manipulation functions
 

-mul(g)[source]

+mul(g)[source]
 
Multiply two polynomials f and g.

 
Examples

 
>>> from sympy import Poly
@@ -3964,7 +3964,7 @@ 
Basic polynomial manipulation functions
 

-mul_ground(coeff)[source]

+mul_ground(coeff)[source]
 
Multiply f by a an element of the ground domain.

 
Examples

 
>>> from sympy import Poly
@@ -3979,7 +3979,7 @@ 
Basic polynomial manipulation functions
 

-neg()[source]

+neg()[source]
 
Negate all coefficients in f.

 
Examples

 
>>> from sympy import Poly
@@ -3998,13 +3998,13 @@ 
Basic polynomial manipulation functions
 

-classmethod new(rep, *gens)[source]

+classmethod new(rep, *gens)[source]
 
Construct Poly instance from raw representation.

 

 
 

 

-norm()[source]

+norm()[source]
 
Computes the product, Norm(f), of the conjugates of
 a polynomial f defined over a number field K.

 
Examples

@@ -4033,7 +4033,7 @@ 
Basic polynomial manipulation functions
 

-nroots(n=15, maxsteps=50, cleanup=True)[source]

+nroots(n=15, maxsteps=50, cleanup=True)[source]
 
Compute numerical approximations of roots of f.

 

 
Parameters:

@@ -4058,7 +4058,7 @@ 
Basic polynomial manipulation functions
 

-nth(*N)[source]

+nth(*N)[source]
 
Returns the n-th coefficient of f where N are the
 exponents of the generators in the term of interest.

 
Examples

@@ -4084,7 +4084,7 @@ 
Basic polynomial manipulation functions
 

-nth_power_roots_poly(n)[source]

+nth_power_roots_poly(n)[source]
 
Construct a polynomial with n-th powers of roots of f.

 
Examples

 
>>> from sympy import Poly
@@ -4114,7 +4114,7 @@ 
Basic polynomial manipulation functions
 

-pdiv(g)[source]

+pdiv(g)[source]
 
Polynomial pseudo-division of f by g.

 
Examples

 
>>> from sympy import Poly
@@ -4129,7 +4129,7 @@ 
Basic polynomial manipulation functions
 

-per(rep, gens=None, remove=None)[source]

+per(rep, gens=None, remove=None)[source]
 
Create a Poly out of the given representation.

 
Examples

 
>>> from sympy import Poly, ZZ
@@ -4150,7 +4150,7 @@ 
Basic polynomial manipulation functions
 

-pexquo(g)[source]

+pexquo(g)[source]
 
Polynomial exact pseudo-quotient of f by g.

 
Examples

 
>>> from sympy import Poly
@@ -4171,7 +4171,7 @@ 
Basic polynomial manipulation functions
 

-pow(n)[source]

+pow(n)[source]
 
Raise f to a non-negative power n.

 
Examples

 
>>> from sympy import Poly
@@ -4190,7 +4190,7 @@ 
Basic polynomial manipulation functions
 

-pquo(g)[source]

+pquo(g)[source]
 
Polynomial pseudo-quotient of f by g.

 
See the Caveat note in the function prem(f, g).

 
Examples

@@ -4210,7 +4210,7 @@ 
Basic polynomial manipulation functions
 

-prem(g)[source]

+prem(g)[source]
 
Polynomial pseudo-remainder of f by g.

 

 
Caveat: The function prem(f, g, x) can be safely used to compute
in Z[x] _only_ subresultant polynomial remainder sequences (prs’s).

@@ -4239,7 +4239,7 @@ 
Basic polynomial manipulation functions
 

-primitive()[source]

+primitive()[source]
 
Returns the content and a primitive form of f.

 
Examples

 
>>> from sympy import Poly
@@ -4254,7 +4254,7 @@ 
Basic polynomial manipulation functions
 

-quo(g, auto=True)[source]

+quo(g, auto=True)[source]
 
Computes polynomial quotient of f by g.

 
Examples

 
>>> from sympy import Poly
@@ -4273,7 +4273,7 @@ 
Basic polynomial manipulation functions
 

-quo_ground(coeff)[source]

+quo_ground(coeff)[source]
 
Quotient of f by a an element of the ground domain.

 
Examples

 
>>> from sympy import Poly
@@ -4292,7 +4292,7 @@ 
Basic polynomial manipulation functions
 

-rat_clear_denoms(g)[source]

+rat_clear_denoms(g)[source]
 
Clear denominators in a rational function f/g.

 
Examples

 
>>> from sympy import Poly
@@ -4316,7 +4316,7 @@ 
Basic polynomial manipulation functions
 

-real_roots(multiple=True, radicals=True)[source]

+real_roots(multiple=True, radicals=True)[source]
 
Return a list of real roots with multiplicities.

 
See real_roots() for more explanation.

 
Examples

@@ -4345,7 +4345,7 @@ 
Basic polynomial manipulation functionscheck_sqf=False,

 

 
-)[source]
+)[source]
 
Refine an isolating interval of a root to the given precision.

 
Examples

 
>>> from sympy import Poly
@@ -4360,7 +4360,7 @@ 
Basic polynomial manipulation functions
 

-rem(g, auto=True)[source]

+rem(g, auto=True)[source]
 
Computes the polynomial remainder of f by g.

 
Examples

 
>>> from sympy import Poly
@@ -4379,7 +4379,7 @@ 
Basic polynomial manipulation functions
 

-reorder(*gens, **args)[source]

+reorder(*gens, **args)[source]
 
Efficiently apply new order of generators.

 
Examples

 
>>> from sympy import Poly
@@ -4394,7 +4394,7 @@ 
Basic polynomial manipulation functions
 

-replace(x, y=None, **_ignore)[source]

+replace(x, y=None, **_ignore)[source]
 
Replace x with y in generators list.

 
Examples

 
>>> from sympy import Poly
@@ -4409,7 +4409,7 @@ 
Basic polynomial manipulation functions
 

-resultant(g, includePRS=False)[source]

+resultant(g, includePRS=False)[source]
 
Computes the resultant of f and g via PRS.

 
If includePRS=True, it includes the subresultant PRS in the result.
 Because the PRS is used to calculate the resultant, this is more
@@ -4433,7 +4433,7 @@ 
Basic polynomial manipulation functions
 

-retract(field=None)[source]

+retract(field=None)[source]
 
Recalculate the ground domain of a polynomial.

 
Examples

 
>>> from sympy import Poly
@@ -4455,7 +4455,7 @@ 
Basic polynomial manipulation functions
 

-revert(n)[source]

+revert(n)[source]
 
Compute f**(-1) mod x**n.

 
Examples

 
>>> from sympy import Poly
@@ -4486,7 +4486,7 @@ 
Basic polynomial manipulation functions
 

-root(index, radicals=True)[source]

+root(index, radicals=True)[source]
 
Get an indexed root of a polynomial.

 
Examples

 
>>> from sympy import Poly
@@ -4516,7 +4516,7 @@ 
Basic polynomial manipulation functions
 

-same_root(a, b)[source]

+same_root(a, b)[source]
 
Decide whether two roots of this polynomial are equal.

 

 
Raises:

@@ -4552,13 +4552,13 @@ 
Basic polynomial manipulation functions
 

-set_domain(domain)[source]

+set_domain(domain)[source]
 
Set the ground domain of f.

 

 
 

 

-set_modulus(modulus)[source]

+set_modulus(modulus)[source]
 
Set the modulus of f.

 
Examples

 
>>> from sympy import Poly
@@ -4573,7 +4573,7 @@ 
Basic polynomial manipulation functions
 

-shift(a)[source]

+shift(a)[source]
 
Efficiently compute Taylor shift f(x + a).

 
Examples

 
>>> from sympy import Poly
@@ -4595,7 +4595,7 @@ 
Basic polynomial manipulation functions
 

-shift_list(a)[source]

+shift_list(a)[source]
 
Efficiently compute Taylor shift f(X + A).

 
Examples

 
>>> from sympy import Poly
@@ -4617,13 +4617,13 @@ 
Basic polynomial manipulation functions
 

-slice(x, m, n=None)[source]

+slice(x, m, n=None)[source]
 
Take a continuous subsequence of terms of f.

 

 
 

 

-sqf_list(all=False)[source]

+sqf_list(all=False)[source]
 
Returns a list of square-free factors of f.

 
Examples

 
>>> from sympy import Poly
@@ -4648,7 +4648,7 @@ 
Basic polynomial manipulation functions
 

-sqf_list_include(all=False)[source]

+sqf_list_include(all=False)[source]
 
Returns a list of square-free factors of f.

 
Examples

 
>>> from sympy import Poly, expand
@@ -4677,7 +4677,7 @@ 
Basic polynomial manipulation functions
 

-sqf_norm()[source]

+sqf_norm()[source]
 
Computes square-free norm of f.

 
Returns s, f, r, such that g(x) = f(x-sa) and
 r(x) = Norm(g(x)) is a square-free polynomial over K,
@@ -4702,7 +4702,7 @@ 
Basic polynomial manipulation functions
 

-sqf_part()[source]

+sqf_part()[source]
 
Computes square-free part of f.

 
Examples

 
>>> from sympy import Poly
@@ -4717,7 +4717,7 @@ 
Basic polynomial manipulation functions
 

-sqr()[source]

+sqr()[source]
 
Square a polynomial f.

 
Examples

 
>>> from sympy import Poly
@@ -4736,7 +4736,7 @@ 
Basic polynomial manipulation functions
 

-sturm(auto=True)[source]

+sturm(auto=True)[source]
 
Computes the Sturm sequence of f.

 
Examples

 
>>> from sympy import Poly
@@ -4754,7 +4754,7 @@ 
Basic polynomial manipulation functions
 

-sub(g)[source]

+sub(g)[source]
 
Subtract two polynomials f and g.

 
Examples

 
>>> from sympy import Poly
@@ -4773,7 +4773,7 @@ 
Basic polynomial manipulation functions
 

-sub_ground(coeff)[source]

+sub_ground(coeff)[source]
 
Subtract an element of the ground domain from f.

 
Examples

 
>>> from sympy import Poly
@@ -4788,7 +4788,7 @@ 
Basic polynomial manipulation functions
 

-subresultants(g)[source]

+subresultants(g)[source]
 
Computes the subresultant PRS of f and g.

 
Examples

 
>>> from sympy import Poly
@@ -4805,7 +4805,7 @@ 
Basic polynomial manipulation functions
 

-terms(order=None)[source]

+terms(order=None)[source]
 
Returns all non-zero terms from f in lex order.

 
Examples

 
>>> from sympy import Poly
@@ -4824,7 +4824,7 @@ 
Basic polynomial manipulation functions
 

-terms_gcd()[source]

+terms_gcd()[source]
 
Remove GCD of terms from the polynomial f.

 
Examples

 
>>> from sympy import Poly
@@ -4839,7 +4839,7 @@ 
Basic polynomial manipulation functions
 

-termwise(func, *gens, **args)[source]

+termwise(func, *gens, **args)[source]
 
Apply a function to all terms of f.

 
Examples

 
>>> from sympy import Poly
@@ -4859,7 +4859,7 @@ 
Basic polynomial manipulation functions
 

-to_exact()[source]

+to_exact()[source]
 
Make the ground domain exact.

 
Examples

 
>>> from sympy import Poly, RR
@@ -4874,7 +4874,7 @@ 
Basic polynomial manipulation functions
 

-to_field()[source]

+to_field()[source]
 
Make the ground domain a field.

 
Examples

 
>>> from sympy import Poly, ZZ
@@ -4889,7 +4889,7 @@ 
Basic polynomial manipulation functions
 

-to_ring()[source]

+to_ring()[source]
 
Make the ground domain a ring.

 
Examples

 
>>> from sympy import Poly, QQ
@@ -4904,7 +4904,7 @@ 
Basic polynomial manipulation functions
 

-total_degree()[source]

+total_degree()[source]
 
Returns the total degree of f.

 
Examples

 
>>> from sympy import Poly
@@ -4921,7 +4921,7 @@ 
Basic polynomial manipulation functions
 

-transform(p, q)[source]

+transform(p, q)[source]
 
Efficiently evaluate the functional transformation q**n * f(p/q).

 
Examples

 
>>> from sympy import Poly
@@ -4936,7 +4936,7 @@ 
Basic polynomial manipulation functions
 

-trunc(p)[source]

+trunc(p)[source]
 
Reduce f modulo a constant p.

 
Examples

 
>>> from sympy import Poly
@@ -4951,7 +4951,7 @@ 
Basic polynomial manipulation functions
 

-unify(g)[source]

+unify(g)[source]
 
Make f and g belong to the same domain.

 
Examples

 
>>> from sympy import Poly
@@ -4986,7 +4986,7 @@ 
Basic polynomial manipulation functions
 

-which_all_roots(candidates)[source]

+which_all_roots(candidates)[source]
 
Find roots of a square-free polynomial f from candidates.

 
Explanation

 
If f is a square-free polynomial and candidates is a superset
@@ -5039,7 +5039,7 @@ 
Basic polynomial manipulation functions
 

-which_real_roots(candidates)[source]

+which_real_roots(candidates)[source]
 
Find roots of a square-free polynomial f from candidates.

 
Explanation

 
If f is a square-free polynomial and candidates is a superset
@@ -5096,7 +5096,7 @@ 
Basic polynomial manipulation functions
 

-class sympy.polys.polytools.PurePoly(rep, *gens, **args)[source]

+class sympy.polys.polytools.PurePoly(rep, *gens, **args)[source]
 
Class for representing pure polynomials.

 

 

@@ -5121,11 +5121,11 @@ 
Basic polynomial manipulation functions
 

-class sympy.polys.polytools.GroebnerBasis(F, *gens, **args)[source]

+class sympy.polys.polytools.GroebnerBasis(F, *gens, **args)[source]

 
Represents a reduced Groebner basis.

 

 

-contains(poly)[source]

+contains(poly)[source]
 
Check if poly belongs the ideal generated by self.

 
Examples

 
>>> from sympy import groebner
@@ -5146,7 +5146,7 @@ 
Basic polynomial manipulation functions
 

-fglm(order)[source]

+fglm(order)[source]
 
Convert a Groebner basis from one ordering to another.

 
The FGLM algorithm converts reduced Groebner bases of zero-dimensional
 ideals from one ordering to another. This method is often used when it
@@ -5191,7 +5191,7 @@ 
Basic polynomial manipulation functions
 

-reduce(expr, auto=True)[source]

+reduce(expr, auto=True)[source]
 
Reduces a polynomial modulo a Groebner basis.

 
Given a polynomial f and a set of polynomials G = (g_1, ..., g_n),
 computes a set of quotients q = (q_1, ..., q_n) and the remainder r
@@ -5226,7 +5226,7 @@ 
Basic polynomial manipulation functions

 

 

-sympy.polys.polyfuncs.symmetrize(F, *gens, **args)[source]

+sympy.polys.polyfuncs.symmetrize(F, *gens, **args)[source]
 
Rewrite a polynomial in terms of elementary symmetric polynomials.

 
A symmetric polynomial is a multivariate polynomial that remains invariant
 under any variable permutation, i.e., if \(f = f(x_1, x_2, \dots, x_n)\),
@@ -5260,7 +5260,7 @@ 
Extra polynomial manipulation functions
 

-sympy.polys.polyfuncs.horner(f, *gens, **args)[source]

+sympy.polys.polyfuncs.horner(f, *gens, **args)[source]
 
Rewrite a polynomial in Horner form.

 
Among other applications, evaluation of a polynomial at a point is optimal
 when it is applied using the Horner scheme ([1]).

@@ -5294,7 +5294,7 @@ 
Extra polynomial manipulation functions
 

-sympy.polys.polyfuncs.interpolate(data, x)[source]

+sympy.polys.polyfuncs.interpolate(data, x)[source]
 
Construct an interpolating polynomial for the data points
 evaluated at point x (which can be symbolic or numeric).

 
Examples

@@ -5336,7 +5336,7 @@ 
Extra polynomial manipulation functions
 

-sympy.polys.polyfuncs.viete(f, roots=None, *gens, **args)[source]

+sympy.polys.polyfuncs.viete(f, roots=None, *gens, **args)[source]
 
Generate Viete’s formulas for f.

 
Examples

 
>>> from sympy.polys.polyfuncs import viete
@@ -5357,7 +5357,7 @@ 
Extra polynomial manipulation functions

 

 

-sympy.polys.constructor.construct_domain(obj, **args)[source]

+sympy.polys.constructor.construct_domain(obj, **args)[source]
 
Construct a minimal domain for a list of expressions.

 

 
Parameters:

@@ -5441,23 +5441,23 @@ 
Domain constructors

 

 

-class sympy.polys.monomials.Monomial(monom, gens=None)[source]

+class sympy.polys.monomials.Monomial(monom, gens=None)[source]
 
Class representing a monomial, i.e. a product of powers.

 

 

-as_expr(*gens)[source]

+as_expr(*gens)[source]
 
Convert a monomial instance to a SymPy expression.

 

 
 

 

-gcd(other)[source]

+gcd(other)[source]
 
Greatest common divisor of monomials.

 

 
 

 

-lcm(other)[source]

+lcm(other)[source]
 
Least common multiple of monomials.

 

 
@@ -5473,7 +5473,7 @@ 
Monomials encoded as tuplesmin_degrees=None,

 

 
-)[source]
+)[source]
 
max_degrees and min_degrees are either both integers or both lists.
 Unless otherwise specified, min_degrees is either 0 or
 [0, ..., 0].

@@ -5544,7 +5544,7 @@ 
Monomials encoded as tuples
 

-sympy.polys.monomials.monomial_count(V, N)[source]

+sympy.polys.monomials.monomial_count(V, N)[source]
 
Computes the number of monomials.

 
The number of monomials is given by the following formula:

 

@@ -5578,25 +5578,25 @@ 
Monomials encoded as tuples

 

 

-class sympy.polys.orderings.MonomialOrder[source]

+class sympy.polys.orderings.MonomialOrder[source]
 
Base class for monomial orderings.

 

 
 

 

-class sympy.polys.orderings.LexOrder[source]

+class sympy.polys.orderings.LexOrder[source]
 
Lexicographic order of monomials.

 

 
 

 

-class sympy.polys.orderings.GradedLexOrder[source]

+class sympy.polys.orderings.GradedLexOrder[source]
 
Graded lexicographic order of monomials.

 

 
 

 

-class sympy.polys.orderings.ReversedGradedLexOrder[source]

+class sympy.polys.orderings.ReversedGradedLexOrder[source]
 
Reversed graded lexicographic order of monomials.

 

 
@@ -5615,7 +5615,7 @@ 
Formal manipulation of roots of polynomialsexpand=True,

 

 
-)[source]
+)[source]
 
An indexed root of a univariate polynomial.

 
Returns either a ComplexRootOf object or an explicit
 expression involving radicals.

@@ -5654,7 +5654,7 @@ 
Formal manipulation of roots of polynomialsexpand=True,

 

 
-)[source]
+)[source]
 
Represents a root of a univariate polynomial.

 
Base class for roots of different kinds of polynomials.
 Only complex roots are currently supported.

@@ -5672,7 +5672,7 @@ 
Formal manipulation of roots of polynomialsexpand=True,

 

 
-)[source]
+)[source]
 
Represents an indexed complex root of a polynomial.

 
Roots of a univariate polynomial separated into disjoint
 real or complex intervals and indexed in a fixed order:

@@ -5795,56 +5795,56 @@ 
Formal manipulation of roots of polynomials
 

-classmethod _all_roots(poly, use_cache=True)[source]

+classmethod _all_roots(poly, use_cache=True)[source]
 
Get real and complex roots of a composite polynomial.

 

 
 

 

-classmethod _complexes_index(complexes, index)[source]

+classmethod _complexes_index(complexes, index)[source]
 
Map initial complex root index to an index in a factor where
 the root belongs.

 

 
 

 

-classmethod _complexes_sorted(complexes)[source]

+classmethod _complexes_sorted(complexes)[source]
 
Make complex isolating intervals disjoint and sort roots.

 

 
 

 

-classmethod _count_roots(roots)[source]

+classmethod _count_roots(roots)[source]
 
Count the number of real or complex roots with multiplicities.

 

 
 

 

-_ensure_complexes_init()[source]

+_ensure_complexes_init()[source]
 
Ensure that our poly has entries in the complexes cache.

 

 
 

 

-_ensure_reals_init()[source]

+_ensure_reals_init()[source]
 
Ensure that our poly has entries in the reals cache.

 

 
 

 

-_eval_evalf(prec, **kwargs)[source]

+_eval_evalf(prec, **kwargs)[source]
 
Evaluate this complex root to the given precision.

 

 
 

 

-_eval_is_imaginary()[source]

+_eval_is_imaginary()[source]
 
Return True if the root is imaginary.

 

 
 

 

-_eval_is_real()[source]

+_eval_is_real()[source]
 
Return True if the root is real.

 

 
@@ -5857,7 +5857,7 @@ 
Formal manipulation of roots of polynomialsuse_cache=True,

 

 
-)[source]
+)[source]
 
Compute complex root isolating intervals for a list of factors.

 

 
@@ -5870,19 +5870,19 @@ 
Formal manipulation of roots of polynomialsuse_cache=True,

 

 
-)[source]
+)[source]
 
Get complex root isolating intervals for a square-free factor.

 

 
 

 

-_get_interval()[source]

+_get_interval()[source]
 
Internal function for retrieving isolation interval from cache.

 

 
 

 

-classmethod _get_reals(factors, use_cache=True)[source]

+classmethod _get_reals(factors, use_cache=True)[source]
 
Compute real root isolating intervals for a list of factors.

 

 
@@ -5895,13 +5895,13 @@ 
Formal manipulation of roots of polynomialsuse_cache=True,

 

 
-)[source]
+)[source]
 
Get real root isolating intervals for a square-free factor.

 

 
 

 

-classmethod _get_roots(method, poly, radicals)[source]

+classmethod _get_roots(method, poly, radicals)[source]
 
Return postprocessed roots of specified kind.

 

 
@@ -5915,7 +5915,7 @@ 
Formal manipulation of roots of polynomialsradicals,

 

 
-)[source]
+)[source]
 
Return postprocessed roots of specified kind
 for polynomials with algebraic coefficients. It assumes
 the domain is already an algebraic field. First it
@@ -5934,7 +5934,7 @@ 
Formal manipulation of roots of polynomialsradicals,

 

 
-)[source]
+)[source]
 
Return postprocessed roots of specified kind
 for polynomials with rational coefficients.

 

@@ -5949,50 +5949,50 @@ 
Formal manipulation of roots of polynomialslazy=False,

 

 
-)[source]
+)[source]
 
Get a root of a composite polynomial by index.

 

 
 

 

-classmethod _new(poly, index)[source]

+classmethod _new(poly, index)[source]
 
Construct new CRootOf object from raw data.

 

 
 

 

-classmethod _postprocess_root(root, radicals)[source]

+classmethod _postprocess_root(root, radicals)[source]
 
Return the root if it is trivial or a CRootOf object.

 

 
 

 

-classmethod _preprocess_roots(poly)[source]

+classmethod _preprocess_roots(poly)[source]
 
Take heroic measures to make poly compatible with CRootOf.

 

 
 

 

-classmethod _real_roots(poly)[source]

+classmethod _real_roots(poly)[source]
 
Get real roots of a composite polynomial.

 

 
 

 

-classmethod _reals_index(reals, index)[source]

+classmethod _reals_index(reals, index)[source]
 
Map initial real root index to an index in a factor where
 the root belongs.

 

 
 

 

-classmethod _reals_sorted(reals)[source]

+classmethod _reals_sorted(reals)[source]
 
Make real isolating intervals disjoint and sort roots.

 

 
 

 

-classmethod _refine_complexes(complexes)[source]

+classmethod _refine_complexes(complexes)[source]
 
return complexes such that no bounding rectangles of non-conjugate
 roots would intersect. In addition, assure that neither ay nor by is
 0 to guarantee that non-real roots are distinct from real roots in
@@ -6001,31 +6001,31 @@ 
Formal manipulation of roots of polynomials
 

-_reset()[source]

+_reset()[source]
 
Reset all intervals

 

 
 

 

-classmethod _roots_trivial(poly, radicals)[source]

+classmethod _roots_trivial(poly, radicals)[source]
 
Compute roots in linear, quadratic and binomial cases.

 

 
 

 

-_set_interval(interval)[source]

+_set_interval(interval)[source]
 
Internal function for updating isolation interval in cache.

 

 
 

 

-classmethod all_roots(poly, radicals=True)[source]

+classmethod all_roots(poly, radicals=True)[source]
 
Get real and complex roots of a polynomial.

 

 
 

 

-classmethod clear_cache()[source]

+classmethod clear_cache()[source]
 
Reset cache for reals and complexes.

 
The intervals used to approximate a root instance are updated
 as needed. When a request is made to see the intervals, the
@@ -6039,7 +6039,7 @@ 
Formal manipulation of roots of polynomials
 

-eval_approx(n, return_mpmath=False)[source]

+eval_approx(n, return_mpmath=False)[source]
 
Evaluate this complex root to the given precision.

 
This uses secant method and root bounds are used to both
 generate an initial guess and to check that the root
@@ -6057,7 +6057,7 @@ 
Formal manipulation of roots of polynomialsn=15,

 

 
-)[source]
+)[source]
 
Return a Rational approximation of self that has real
 and imaginary component approximations that are within dx
 and dy of the true values, respectively. Alternatively,
@@ -6090,7 +6090,7 @@ 
Formal manipulation of roots of polynomials
 

-classmethod real_roots(poly, radicals=True)[source]

+classmethod real_roots(poly, radicals=True)[source]
 
Get real roots of a polynomial.

 

 
@@ -6108,11 +6108,11 @@ 
Formal manipulation of roots of polynomialsquadratic=False,

 

 
-)[source]
+)[source]
 
Represents a sum of all roots of a univariate polynomial.

 

 

-classmethod new(poly, func, auto=True)[source]

+classmethod new(poly, func, auto=True)[source]
 
Construct new RootSum instance.

 

 
@@ -6140,7 +6140,7 @@ 
Symbolic root-finding algorithms**flags,

 

 
-)[source]
+)[source]
 
Computes symbolic roots of a univariate polynomial.

 
Given a univariate polynomial f with symbolic coefficients (or
 a list of the polynomial’s coefficients), returns a dictionary
@@ -6242,7 +6242,7 @@ 
Symbolic root-finding algorithms

 

 

-sympy.polys.specialpolys.swinnerton_dyer_poly(n, x=None, polys=False)[source]

+sympy.polys.specialpolys.swinnerton_dyer_poly(n, x=None, polys=False)[source]
 
Generates n-th Swinnerton-Dyer polynomial in \(x\).

 

 
Parameters:

@@ -6262,7 +6262,7 @@ 
Special polynomials
 

-sympy.polys.specialpolys.interpolating_poly(n, x, X='x', Y='y')[source]

+sympy.polys.specialpolys.interpolating_poly(n, x, X='x', Y='y')[source]
 
Construct Lagrange interpolating polynomial for n
 data points. If a sequence of values are given for X and Y
 then the first n values will be used.

@@ -6270,7 +6270,7 @@ 
Special polynomials
 

-sympy.polys.specialpolys.cyclotomic_poly(n, x=None, polys=False)[source]

+sympy.polys.specialpolys.cyclotomic_poly(n, x=None, polys=False)[source]
 
Generates cyclotomic polynomial of order \(n\) in \(x\).

 

 
Parameters:

@@ -6290,7 +6290,7 @@ 
Special polynomials
 

-sympy.polys.specialpolys.symmetric_poly(n, *gens, polys=False)[source]

+sympy.polys.specialpolys.symmetric_poly(n, *gens, polys=False)[source]
 
Generates symmetric polynomial of order \(n\).

 

 
Parameters:

@@ -6316,7 +6316,7 @@ 
Special polynomialspolys=False,

 

 
-)[source]
+)[source]
 
Generates a polynomial of degree n with coefficients in
 [inf, sup].

 

@@ -6356,7 +6356,7 @@ 
Special polynomials

 

 

-sympy.polys.orthopolys.chebyshevt_poly(n, x=None, polys=False)[source]

+sympy.polys.orthopolys.chebyshevt_poly(n, x=None, polys=False)[source]
 
Generates the Chebyshev polynomial of the first kind \(T_n(x)\).

 

 
Parameters:

@@ -6375,7 +6375,7 @@ 
Orthogonal polynomials
 

-sympy.polys.orthopolys.chebyshevu_poly(n, x=None, polys=False)[source]

+sympy.polys.orthopolys.chebyshevu_poly(n, x=None, polys=False)[source]
 
Generates the Chebyshev polynomial of the second kind \(U_n(x)\).

 

 
Parameters:

@@ -6394,7 +6394,7 @@ 
Orthogonal polynomials
 

-sympy.polys.orthopolys.gegenbauer_poly(n, a, x=None, polys=False)[source]

+sympy.polys.orthopolys.gegenbauer_poly(n, a, x=None, polys=False)[source]
 
Generates the Gegenbauer polynomial \(C_n^{(a)}(x)\).

 

 
Parameters:

@@ -6417,7 +6417,7 @@ 
Orthogonal polynomials
 

-sympy.polys.orthopolys.hermite_poly(n, x=None, polys=False)[source]

+sympy.polys.orthopolys.hermite_poly(n, x=None, polys=False)[source]
 
Generates the Hermite polynomial \(H_n(x)\).

 

 
Parameters:

@@ -6436,7 +6436,7 @@ 
Orthogonal polynomials
 

-sympy.polys.orthopolys.hermite_prob_poly(n, x=None, polys=False)[source]

+sympy.polys.orthopolys.hermite_prob_poly(n, x=None, polys=False)[source]
 
Generates the probabilist’s Hermite polynomial \(He_n(x)\).

 

 
Parameters:

@@ -6455,7 +6455,7 @@ 
Orthogonal polynomials
 

-sympy.polys.orthopolys.jacobi_poly(n, a, b, x=None, polys=False)[source]

+sympy.polys.orthopolys.jacobi_poly(n, a, b, x=None, polys=False)[source]
 
Generates the Jacobi polynomial \(P_n^{(a,b)}(x)\).

 

 
Parameters:

@@ -6482,7 +6482,7 @@ 
Orthogonal polynomials
 

-sympy.polys.orthopolys.legendre_poly(n, x=None, polys=False)[source]

+sympy.polys.orthopolys.legendre_poly(n, x=None, polys=False)[source]
 
Generates the Legendre polynomial \(P_n(x)\).

 

 
Parameters:

@@ -6501,7 +6501,7 @@ 
Orthogonal polynomials
 

-sympy.polys.orthopolys.laguerre_poly(n, x=None, alpha=0, polys=False)[source]

+sympy.polys.orthopolys.laguerre_poly(n, x=None, alpha=0, polys=False)[source]
 
Generates the Laguerre polynomial \(L_n^{(\alpha)}(x)\).

 

 
Parameters:

@@ -6524,7 +6524,7 @@ 
Orthogonal polynomials
 

-sympy.polys.orthopolys.spherical_bessel_fn(n, x=None, polys=False)[source]

+sympy.polys.orthopolys.spherical_bessel_fn(n, x=None, polys=False)[source]
 
Coefficients for the spherical Bessel functions.

 
These are only needed in the jn() function.

 
The coefficients are calculated from:

@@ -6565,7 +6565,7 @@ 
Orthogonal polynomialsAppell sequences

 

 

-sympy.polys.appellseqs.bernoulli_poly(n, x=None, polys=False)[source]

+sympy.polys.appellseqs.bernoulli_poly(n, x=None, polys=False)[source]
 
Generates the Bernoulli polynomial \(\operatorname{B}_n(x)\).

 
\(\operatorname{B}_n(x)\) is the unique polynomial satisfying

 

@@ -6633,7 +6633,7 @@ 
Appell sequences
 

-sympy.polys.appellseqs.bernoulli_c_poly(n, x=None, polys=False)[source]

+sympy.polys.appellseqs.bernoulli_c_poly(n, x=None, polys=False)[source]
 
Generates the central Bernoulli polynomial \(\operatorname{B}_n^c(x)\).

 
These are scaled and shifted versions of the plain Bernoulli polynomials,
 done in such a way that \(\operatorname{B}_n^c(x)\) is an even or odd function
@@ -6660,7 +6660,7 @@ 
Appell sequences
 

-sympy.polys.appellseqs.genocchi_poly(n, x=None, polys=False)[source]

+sympy.polys.appellseqs.genocchi_poly(n, x=None, polys=False)[source]
 
Generates the Genocchi polynomial \(\operatorname{G}_n(x)\).

 
\(\operatorname{G}_n(x)\) is twice the difference between the plain and
 central Bernoulli polynomials, so has degree \(n-1\):

@@ -6692,7 +6692,7 @@ 
Appell sequences
 

-sympy.polys.appellseqs.euler_poly(n, x=None, polys=False)[source]

+sympy.polys.appellseqs.euler_poly(n, x=None, polys=False)[source]
 
Generates the Euler polynomial \(\operatorname{E}_n(x)\).

 
These are scaled and reindexed versions of the Genocchi polynomials:

 

@@ -6720,7 +6720,7 @@ 
Appell sequences
 

-sympy.polys.appellseqs.andre_poly(n, x=None, polys=False)[source]

+sympy.polys.appellseqs.andre_poly(n, x=None, polys=False)[source]
 
Generates the Andre polynomial \(\mathcal{A}_n(x)\).

 
This is the Appell sequence where the constant coefficients form the sequence
 of Euler numbers euler(n). As such they have integer coefficients
@@ -6788,7 +6788,7 @@ 
Appell sequences

 

 

-sympy.polys.rationaltools.together(expr, deep=False, fraction=True)[source]

+sympy.polys.rationaltools.together(expr, deep=False, fraction=True)[source]
 
Denest and combine rational expressions using symbolic methods.

 
This function takes an expression or a container of expressions
 and puts it (them) together by denesting and combining rational
@@ -6846,7 +6846,7 @@ 
Manipulation of rational functions

 

 

-sympy.polys.partfrac.apart(f, x=None, full=False, **options)[source]

+sympy.polys.partfrac.apart(f, x=None, full=False, **options)[source]
 
Compute partial fraction decomposition of a rational function.

 
Given a rational function f, computes the partial fraction
 decomposition of f. Two algorithms are available: One is based on the
@@ -6896,7 +6896,7 @@ 
Partial fraction decomposition
 

-sympy.polys.partfrac.apart_list(f, x=None, dummies=None, **options)[source]

+sympy.polys.partfrac.apart_list(f, x=None, dummies=None, **options)[source]
 
Compute partial fraction decomposition of a rational function
 and return the result in structured form.

 
Given a rational function f compute the partial fraction decomposition
@@ -7001,7 +7001,7 @@ 
Partial fraction decomposition
 

-sympy.polys.partfrac.assemble_partfrac_list(partial_list)[source]

+sympy.polys.partfrac.assemble_partfrac_list(partial_list)[source]
 
Reassemble a full partial fraction decomposition
 from a structured result obtained by the function apart_list.

 
Examples

@@ -7064,7 +7064,7 @@ 
Partial fraction decomposition

 

 

-sympy.polys.dispersion.dispersionset(p, q=None, *gens, **args)[source]

+sympy.polys.dispersion.dispersionset(p, q=None, *gens, **args)[source]
 
Compute the dispersion set of two polynomials.

 
For two polynomials \(f(x)\) and \(g(x)\) with \(\deg f > 0\)
 and \(\deg g > 0\) the dispersion set \(\operatorname{J}(f, g)\) is defined as:

@@ -7147,7 +7147,7 @@ 
Dispersion of Polynomials
 

-sympy.polys.dispersion.dispersion(p, q=None, *gens, **args)[source]

+sympy.polys.dispersion.dispersion(p, q=None, *gens, **args)[source]
 
Compute the dispersion of polynomials.

 
For two polynomials \(f(x)\) and \(g(x)\) with \(\deg f > 0\)
 and \(\deg g > 0\) the dispersion \(\operatorname{dis}(f, g)\) is defined as:

diff --git a/dev/modules/polys/ringseries.html b/dev/modules/polys/ringseries.html
index f9bee22610f..b02b0302ba5 100644
--- a/dev/modules/polys/ringseries.html
+++ b/dev/modules/polys/ringseries.html
@@ -963,7 +963,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_log(p, x, prec)[source]

+sympy.polys.ring_series.rs_log(p, x, prec)[source]
 
The Logarithm of p modulo O(x**prec).

 
Notes

 
Truncation of integral dx p**-1*d p/dx is used.

@@ -982,7 +982,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_LambertW(p, x, prec)[source]

+sympy.polys.ring_series.rs_LambertW(p, x, prec)[source]
 
Calculate the series expansion of the principal branch of the Lambert W
 function.

 
Examples

@@ -1002,7 +1002,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_exp(p, x, prec)[source]

+sympy.polys.ring_series.rs_exp(p, x, prec)[source]
 
Exponentiation of a series modulo O(x**prec)

 
Examples

 
>>> from sympy.polys.domains import QQ
@@ -1017,7 +1017,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_atan(p, x, prec)[source]

+sympy.polys.ring_series.rs_atan(p, x, prec)[source]
 
The arctangent of a series

 
Return the series expansion of the atan of p, about 0.

 
Examples

@@ -1037,7 +1037,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_asin(p, x, prec)[source]

+sympy.polys.ring_series.rs_asin(p, x, prec)[source]
 
Arcsine of a series

 
Return the series expansion of the asin of p, about 0.

 
Examples

@@ -1057,7 +1057,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_tan(p, x, prec)[source]

+sympy.polys.ring_series.rs_tan(p, x, prec)[source]
 

 
Tangent of a series.

 
Return the series expansion of the tan of p, about 0.

@@ -1079,7 +1079,7 @@ 
Reference
 

-sympy.polys.ring_series._tan1(p, x, prec)[source]

+sympy.polys.ring_series._tan1(p, x, prec)[source]
 
Helper function of rs_tan().

 
Return the series expansion of tan of a univariate series using Newton’s
 method. It takes advantage of the fact that series expansion of atan is
@@ -1092,7 +1092,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_cot(p, x, prec)[source]

+sympy.polys.ring_series.rs_cot(p, x, prec)[source]
 
Cotangent of a series

 
Return the series expansion of the cot of p, about 0.

 
Examples

@@ -1112,7 +1112,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_sin(p, x, prec)[source]

+sympy.polys.ring_series.rs_sin(p, x, prec)[source]
 
Sine of a series

 
Return the series expansion of the sin of p, about 0.

 
Examples

@@ -1134,7 +1134,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_cos(p, x, prec)[source]

+sympy.polys.ring_series.rs_cos(p, x, prec)[source]
 
Cosine of a series

 
Return the series expansion of the cos of p, about 0.

 
Examples

@@ -1156,14 +1156,14 @@ 
Reference
 

-sympy.polys.ring_series.rs_cos_sin(p, x, prec)[source]

+sympy.polys.ring_series.rs_cos_sin(p, x, prec)[source]
 
Return the tuple (rs_cos(p, x, prec)`, `rs_sin(p, x, prec)).

 
Is faster than calling rs_cos and rs_sin separately

 

 
 

 

-sympy.polys.ring_series.rs_atanh(p, x, prec)[source]

+sympy.polys.ring_series.rs_atanh(p, x, prec)[source]
 
Hyperbolic arctangent of a series

 
Return the series expansion of the atanh of p, about 0.

 
Examples

@@ -1183,7 +1183,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_sinh(p, x, prec)[source]

+sympy.polys.ring_series.rs_sinh(p, x, prec)[source]
 
Hyperbolic sine of a series

 
Return the series expansion of the sinh of p, about 0.

 
Examples

@@ -1203,7 +1203,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_cosh(p, x, prec)[source]

+sympy.polys.ring_series.rs_cosh(p, x, prec)[source]
 
Hyperbolic cosine of a series

 
Return the series expansion of the cosh of p, about 0.

 
Examples

@@ -1223,7 +1223,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_tanh(p, x, prec)[source]

+sympy.polys.ring_series.rs_tanh(p, x, prec)[source]
 
Hyperbolic tangent of a series

 
Return the series expansion of the tanh of p, about 0.

 
Examples

@@ -1243,7 +1243,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_hadamard_exp(p1, inverse=False)[source]

+sympy.polys.ring_series.rs_hadamard_exp(p1, inverse=False)[source]
 
Return sum f_i/i!*x**i from sum f_i*x**i,
 where x is the first variable.

 
If invers=True return sum f_i*i!*x**i

@@ -1262,7 +1262,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_mul(p1, p2, x, prec)[source]

+sympy.polys.ring_series.rs_mul(p1, p2, x, prec)[source]
 
Return the product of the given two series, modulo O(x**prec).

 
x is the series variable or its position in the generators.

 
Examples

@@ -1280,7 +1280,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_square(p1, x, prec)[source]

+sympy.polys.ring_series.rs_square(p1, x, prec)[source]
 
Square the series modulo O(x**prec)

 
Examples

 
>>> from sympy.polys.domains import QQ
@@ -1296,7 +1296,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_pow(p1, n, x, prec)[source]

+sympy.polys.ring_series.rs_pow(p1, n, x, prec)[source]
 
Return p1**n modulo O(x**prec)

 
Examples

 
>>> from sympy.polys.domains import QQ
@@ -1312,7 +1312,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_series_inversion(p, x, prec)[source]

+sympy.polys.ring_series.rs_series_inversion(p, x, prec)[source]
 
Multivariate series inversion 1/p modulo O(x**prec).

 
Examples

 
>>> from sympy.polys.domains import QQ
@@ -1331,7 +1331,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_series_reversion(p, x, n, y)[source]

+sympy.polys.ring_series.rs_series_reversion(p, x, n, y)[source]
 
Reversion of a series.

 
p is a series with O(x**n) of the form \(p = ax + f(x)\)
 where \(a\) is a number different from 0.

@@ -1376,7 +1376,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_nth_root(p, n, x, prec)[source]

+sympy.polys.ring_series.rs_nth_root(p, n, x, prec)[source]
 
Multivariate series expansion of the nth root of p.

 

 
Parameters:

@@ -1416,7 +1416,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_trunc(p1, x, prec)[source]

+sympy.polys.ring_series.rs_trunc(p1, x, prec)[source]
 
Truncate the series in the x variable with precision prec,
 that is, modulo O(x**prec)

 
Examples

@@ -1435,7 +1435,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_subs(p, rules, x, prec)[source]

+sympy.polys.ring_series.rs_subs(p, rules, x, prec)[source]
 
Substitution with truncation according to the mapping in rules.

 
Return a series with precision prec in the generator x

 
Note that substitutions are not done one after the other

@@ -1476,7 +1476,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_diff(p, x)[source]

+sympy.polys.ring_series.rs_diff(p, x)[source]
 
Return partial derivative of p with respect to x.

 

 
Parameters:

@@ -1497,7 +1497,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_integrate(p, x)[source]

+sympy.polys.ring_series.rs_integrate(p, x)[source]
 
Integrate p with respect to x.

 

 
Parameters:

@@ -1518,7 +1518,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_newton(p, x, prec)[source]

+sympy.polys.ring_series.rs_newton(p, x, prec)[source]
 
Compute the truncated Newton sum of the polynomial p

 
Examples

 
>>> from sympy.polys.domains import QQ
@@ -1534,7 +1534,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_compose_add(p1, p2)[source]

+sympy.polys.ring_series.rs_compose_add(p1, p2)[source]
 
compute the composed sum prod(p2(x - beta) for beta root of p1)

 
Examples

 
>>> from sympy.polys.domains import QQ
@@ -1562,7 +1562,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_is_puiseux(p, x)[source]

+sympy.polys.ring_series.rs_is_puiseux(p, x)[source]
 
Test if p is Puiseux series in x.

 
Raise an exception if it has a negative power in x.

 
Examples

@@ -1579,7 +1579,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_puiseux(f, p, x, prec)[source]

+sympy.polys.ring_series.rs_puiseux(f, p, x, prec)[source]
 
Return the puiseux series for \(f(p, x, prec)\).

 
To be used when function f is implemented only for regular series.

 
Examples

@@ -1596,14 +1596,14 @@ 
Reference
 

-sympy.polys.ring_series.rs_puiseux2(f, p, q, x, prec)[source]

+sympy.polys.ring_series.rs_puiseux2(f, p, q, x, prec)[source]
 
Return the puiseux series for \(f(p, q, x, prec)\).

 
To be used when function f is implemented only for regular series.

 

 
 

 

-sympy.polys.ring_series.rs_series_from_list(p, c, x, prec, concur=1)[source]

+sympy.polys.ring_series.rs_series_from_list(p, c, x, prec, concur=1)[source]
 
Return a series \(sum c[n]*p**n\) modulo \(O(x**prec)\).

 
It reduces the number of multiplications by summing concurrently.

 
\(ax = [1, p, p**2, .., p**(J - 1)]\)
@@ -1629,7 +1629,7 @@ 
Reference
 

-sympy.polys.ring_series.rs_fun(p, f, *args)[source]

+sympy.polys.ring_series.rs_fun(p, f, *args)[source]
 
Function of a multivariate series computed by substitution.

 
The case with f method name is used to compute \(rs\_tan\) and \(rs\_nth\_root\)
 of a multivariate series:

@@ -1661,14 +1661,14 @@ 
Reference
 

-sympy.polys.ring_series.mul_xin(p, i, n)[source]

+sympy.polys.ring_series.mul_xin(p, i, n)[source]
 
Return \(p*x_i**n\).

 
\(x\_i\) is the ith variable in p.

 

 
 

 

-sympy.polys.ring_series.pow_xin(p, i, n)[source]

+sympy.polys.ring_series.pow_xin(p, i, n)[source]
 
>>> from sympy.polys.domains import QQ
 >>> from sympy.polys.rings import ring
 >>> from sympy.polys.ring_series import pow_xin
diff --git a/dev/modules/polys/solvers.html b/dev/modules/polys/solvers.html
index 47b65423322..8ebc8bfe0b1 100644
--- a/dev/modules/polys/solvers.html
+++ b/dev/modules/polys/solvers.html
@@ -805,7 +805,7 @@ 
Documentation Version

 
Low-level linear systems solver.

 

 

-sympy.polys.solvers.solve_lin_sys(eqs, ring, _raw=True)[source]

+sympy.polys.solvers.solve_lin_sys(eqs, ring, _raw=True)[source]
 
Solve a system of linear equations from a PolynomialRing

 

 
Parameters:

@@ -874,7 +874,7 @@ 
Documentation Version

 
 

 

-sympy.polys.solvers.eqs_to_matrix(eqs_coeffs, eqs_rhs, gens, domain)[source]

+sympy.polys.solvers.eqs_to_matrix(eqs_coeffs, eqs_rhs, gens, domain)[source]
 
Get matrix from linear equations in dict format.

 

 
Parameters:

@@ -927,7 +927,7 @@ 
Documentation Version

 
 

 

-sympy.polys.solvers.sympy_eqs_to_ring(eqs, symbols)[source]

+sympy.polys.solvers.sympy_eqs_to_ring(eqs, symbols)[source]
 
Convert a system of equations from Expr to a PolyRing

 

 
Parameters:

@@ -975,7 +975,7 @@ 
Documentation Version

 
 

 

-sympy.polys.solvers._solve_lin_sys(eqs_coeffs, eqs_rhs, ring)[source]

+sympy.polys.solvers._solve_lin_sys(eqs_coeffs, eqs_rhs, ring)[source]
 
Solve a linear system from dict of PolynomialRing coefficients

 
Explanation

 
This is an internal function used by solve_lin_sys() after the
@@ -1013,7 +1013,7 @@ 
Documentation Version

 
ring,

 

 
-)[source]
+)[source]
 
Solve a linear system from dict of PolynomialRing coefficients

 
Explanation

 
This is an internal function used by solve_lin_sys() after the
diff --git a/dev/modules/printing.html b/dev/modules/printing.html
index 847220286fd..c16a5fb4e74 100644
--- a/dev/modules/printing.html
+++ b/dev/modules/printing.html
@@ -1012,7 +1012,7 @@ 
Common mistakessource code):

 

 

-class sympy.printing.printer.Printer(settings=None)[source]

+class sympy.printing.printer.Printer(settings=None)[source]
 
Generic printer

 
Its job is to provide infrastructure for implementing new printers easily.

 
If you want to define your custom Printer or your custom printing method
@@ -1024,7 +1024,7 @@ 
Common mistakes
 

-_print(expr, **kwargs) → str[source]

+_print(expr, **kwargs) → str[source]
 
Internal dispatcher

 

 
Tries the following concepts to print an expression:
    
@@ -1038,13 +1038,13 @@ 
    Common mistakes
 
    
-doprint(expr)[source]
    
+doprint(expr)[source]
 
    Returns printer’s representation for expr (as a string)
    
 

 
 

 

-classmethod set_global_settings(**settings)[source]

+classmethod set_global_settings(**settings)[source]
 
Set system-wide printing settings.

 

 
@@ -1066,7 +1066,7 @@ 
PrettyPrinter Class
 

-class sympy.printing.pretty.pretty.PrettyPrinter(settings=None)[source]

+class sympy.printing.pretty.pretty.PrettyPrinter(settings=None)[source]
 
Printer, which converts an expression into 2D ASCII-art figure.

 

 

@@ -1101,7 +1101,7 @@ 
PrettyPrinter Class
 

-sympy.printing.pretty.pretty.pretty_print(expr, **kwargs)[source]

+sympy.printing.pretty.pretty.pretty_print(expr, **kwargs)[source]

 
Prints expr in pretty form.

 
pprint is just a shortcut for this function.

 

@@ -1186,7 +1186,7 @@ 
PrettyPrinter Class
 

-class sympy.printing.c.C89CodePrinter(settings=None)[source]

+class sympy.printing.c.C89CodePrinter(settings=None)[source]
 
A printer to convert Python expressions to strings of C code

 

 

@@ -1195,7 +1195,7 @@ 
PrettyPrinter Class
 

-indent_code(code)[source]

+indent_code(code)[source]

 
Accepts a string of code or a list of code lines

 

 
@@ -1203,7 +1203,7 @@ 
PrettyPrinter Class
 

-class sympy.printing.c.C99CodePrinter(settings=None)[source]

+class sympy.printing.c.C99CodePrinter(settings=None)[source]
 

 

 printmethod: str = '_ccode'

@@ -1222,7 +1222,7 @@ 
PrettyPrinter Class**settings,

 

 
-)[source]
+)[source]
 
Converts an expr to a string of c code

 

 
Parameters:

@@ -1370,7 +1370,7 @@ 
PrettyPrinter Class
 

-sympy.printing.c.print_ccode(expr, **settings)[source]

+sympy.printing.c.print_ccode(expr, **settings)[source]
 
Prints C representation of the given expression.

 

 
@@ -1389,7 +1389,7 @@ 
PrettyPrinter Class
 

-class sympy.printing.cxx.CXX98CodePrinter(settings=None)[source]

+class sympy.printing.cxx.CXX98CodePrinter(settings=None)[source]
 

 

 printmethod: str = '_cxxcode'

@@ -1399,7 +1399,7 @@ 
PrettyPrinter Class
 

-class sympy.printing.cxx.CXX11CodePrinter(settings=None)[source]

+class sympy.printing.cxx.CXX11CodePrinter(settings=None)[source]
 

 

 printmethod: str = '_cxxcode'

@@ -1418,7 +1418,7 @@ 
PrettyPrinter Class**settings,

 

 
-)[source]
+)[source]
 
C++ equivalent of ccode().

 

 
@@ -1446,7 +1446,7 @@ 
PrettyPrinter Class
 

-class sympy.printing.rcode.RCodePrinter(settings={})[source]

+class sympy.printing.rcode.RCodePrinter(settings={})[source]
 
A printer to convert SymPy expressions to strings of R code

 

 

@@ -1455,7 +1455,7 @@ 
PrettyPrinter Class
 

-indent_code(code)[source]

+indent_code(code)[source]

 
Accepts a string of code or a list of code lines

 

 
@@ -1463,7 +1463,7 @@ 
PrettyPrinter Class
 

-sympy.printing.rcode.rcode(expr, assign_to=None, **settings)[source]

+sympy.printing.rcode.rcode(expr, assign_to=None, **settings)[source]
 
Converts an expr to a string of r code

 

 
Parameters:

@@ -1582,7 +1582,7 @@ 
PrettyPrinter Class
 

-sympy.printing.rcode.print_rcode(expr, **settings)[source]

+sympy.printing.rcode.print_rcode(expr, **settings)[source]
 
Prints R representation of the given expression.

 

 
@@ -1597,7 +1597,7 @@ 
Fortran Printing
 

-sympy.printing.fortran.fcode(expr, assign_to=None, **settings)[source]

+sympy.printing.fortran.fcode(expr, assign_to=None, **settings)[source]
 
Converts an expr to a string of fortran code

 

 
Parameters:

@@ -1733,14 +1733,14 @@ 
Fortran Printing
 

-sympy.printing.fortran.print_fcode(expr, **settings)[source]

+sympy.printing.fortran.print_fcode(expr, **settings)[source]
 
Prints the Fortran representation of the given expression.

 
See fcode for the meaning of the optional arguments.

 

 
 

 

-class sympy.printing.fortran.FCodePrinter(settings=None)[source]

+class sympy.printing.fortran.FCodePrinter(settings=None)[source]
 
A printer to convert SymPy expressions to strings of Fortran code

 

 

@@ -1749,7 +1749,7 @@ 
Fortran Printing
 

-indent_code(code)[source]

+indent_code(code)[source]

 
Accepts a string of code or a list of code lines

 

 
@@ -1883,7 +1883,7 @@ 
Fortran Printingsymbol_table=None,

 

 
-)[source]
+)[source]
 

 

 printmethod: str = '_smtlib'

@@ -1914,7 +1914,7 @@ 
Fortran Printinglog_warn=None,

 

 
-)[source]
+)[source]
 
Converts expr to a string of smtlib code.

 

 
Parameters:

@@ -2029,7 +2029,7 @@ 
Fortran Printing
 

-class sympy.printing.mathematica.MCodePrinter(settings={})[source]

+class sympy.printing.mathematica.MCodePrinter(settings={})[source]
 
A printer to convert Python expressions to
 strings of the Wolfram’s Mathematica code

 

@@ -2041,7 +2041,7 @@ 
Fortran Printing
 

-sympy.printing.mathematica.mathematica_code(expr, **settings)[source]

+sympy.printing.mathematica.mathematica_code(expr, **settings)[source]
 
Converts an expr to a string of the Wolfram Mathematica code

 
Examples

 
>>> from sympy import mathematica_code as mcode, symbols, sin
@@ -2057,7 +2057,7 @@ 
Fortran Printing
Maple code printing

 

 

-class sympy.printing.maple.MapleCodePrinter(settings=None)[source]

+class sympy.printing.maple.MapleCodePrinter(settings=None)[source]
 
Printer which converts a SymPy expression into a maple code.

 

 

@@ -2068,7 +2068,7 @@ 
Fortran Printing
 

-sympy.printing.maple.maple_code(expr, assign_to=None, **settings)[source]

+sympy.printing.maple.maple_code(expr, assign_to=None, **settings)[source]

 
Converts expr to a string of Maple code.

 

 
Parameters:

@@ -2120,7 +2120,7 @@ 
Fortran Printing
 

-sympy.printing.maple.print_maple_code(expr, **settings)[source]

+sympy.printing.maple.print_maple_code(expr, **settings)[source]
 
Prints the Maple representation of the given expression.

 
See maple_code() for the meaning of the optional arguments.

 
Examples

@@ -2142,7 +2142,7 @@ 
Fortran Printing
 

-class sympy.printing.jscode.JavascriptCodePrinter(settings={})[source]

+class sympy.printing.jscode.JavascriptCodePrinter(settings={})[source]
 
“A Printer to convert Python expressions to strings of JavaScript code

 

 

@@ -2151,7 +2151,7 @@ 
Fortran Printing
 

-indent_code(code)[source]

+indent_code(code)[source]

 
Accepts a string of code or a list of code lines

 

 
@@ -2159,7 +2159,7 @@ 
Fortran Printing
 

-sympy.printing.jscode.jscode(expr, assign_to=None, **settings)[source]

+sympy.printing.jscode.jscode(expr, assign_to=None, **settings)[source]
 
Converts an expr to a string of javascript code

 

 
Parameters:

@@ -2293,7 +2293,7 @@ 
Fortran Printing
 

-class sympy.printing.julia.JuliaCodePrinter(settings={})[source]

+class sympy.printing.julia.JuliaCodePrinter(settings={})[source]
 
A printer to convert expressions to strings of Julia code.

 

 

@@ -2302,7 +2302,7 @@ 
Fortran Printing
 

-indent_code(code)[source]

+indent_code(code)[source]

 
Accepts a string of code or a list of code lines

 

 
@@ -2310,7 +2310,7 @@ 
Fortran Printing
 

-sympy.printing.julia.julia_code(expr, assign_to=None, **settings)[source]

+sympy.printing.julia.julia_code(expr, assign_to=None, **settings)[source]
 
Converts \(expr\) to a string of Julia code.

 

 
Parameters:

@@ -2477,7 +2477,7 @@ 
Fortran Printing
 

-class sympy.printing.octave.OctaveCodePrinter(settings={})[source]

+class sympy.printing.octave.OctaveCodePrinter(settings={})[source]
 
A printer to convert expressions to strings of Octave/Matlab code.

 

 

@@ -2486,7 +2486,7 @@ 
Fortran Printing
 

-indent_code(code)[source]

+indent_code(code)[source]

 
Accepts a string of code or a list of code lines

 

 
@@ -2494,7 +2494,7 @@ 
Fortran Printing
 

-sympy.printing.octave.octave_code(expr, assign_to=None, **settings)[source]

+sympy.printing.octave.octave_code(expr, assign_to=None, **settings)[source]
 
Converts \(expr\) to a string of Octave (or Matlab) code.

 
The string uses a subset of the Octave language for Matlab compatibility.

 

@@ -2654,7 +2654,7 @@ 
Fortran Printing
 

-class sympy.printing.rust.RustCodePrinter(settings={})[source]

+class sympy.printing.rust.RustCodePrinter(settings={})[source]
 
A printer to convert SymPy expressions to strings of Rust code

 

 

@@ -2663,7 +2663,7 @@ 
Fortran Printing
 

-indent_code(code)[source]

+indent_code(code)[source]

 
Accepts a string of code or a list of code lines

 

 
@@ -2671,7 +2671,7 @@ 
Fortran Printing
 

-sympy.printing.codeprinter.rust_code(expr, assign_to=None, **settings)[source]

+sympy.printing.codeprinter.rust_code(expr, assign_to=None, **settings)[source]
 
Converts an expr to a string of Rust code

 

 
Parameters:

@@ -2798,7 +2798,7 @@ 
Fortran Printing
Aesara Code printing

 

 

-class sympy.printing.aesaracode.AesaraPrinter(*args, **kwargs)[source]

+class sympy.printing.aesaracode.AesaraPrinter(*args, **kwargs)[source]
 
Code printer which creates Aesara symbolic expression graphs.

 

 
Parameters:

@@ -2839,7 +2839,7 @@ 
Fortran Printingbroadcastables=None,

 

 
-)[source]
+)[source]
 
Convert a SymPy expression to a Aesara graph variable.

 
The dtypes and broadcastables arguments are used to specify the
 data type, dimension, and broadcasting behavior of the Aesara variables
@@ -2883,7 +2883,7 @@ 
Fortran Printing
 

-sympy.printing.aesaracode.aesara_code(expr, cache=None, **kwargs)[source]

+sympy.printing.aesaracode.aesara_code(expr, cache=None, **kwargs)[source]
 
Convert a SymPy expression into a Aesara graph variable.

 

 
Parameters:

@@ -2929,7 +2929,7 @@ 
Fortran Printing**kwargs,

 

 
-)[source]
+)[source]
 
Create a Aesara function from SymPy expressions.

 
The inputs and outputs are converted to Aesara variables using
 aesara_code() and then passed to aesara.function.

@@ -3033,7 +3033,7 @@ 
Fortran Printingbroadcastables=None,

 

 
-)[source]
+)[source]
 
Get value of broadcastables argument to aesara_code() from
 keyword arguments to aesara_function().

 
Included for backwards compatibility.

@@ -3084,7 +3084,7 @@ 
Fortran Printing
 

-sympy.printing.gtk.print_gtk(x, start_viewer=True)[source]

+sympy.printing.gtk.print_gtk(x, start_viewer=True)[source]
 
Print to Gtkmathview, a gtk widget capable of rendering MathML.

 
Needs libgtkmathview-bin

 

@@ -3096,7 +3096,7 @@ 
Fortran Printingsympy.utilities.lambdify.lambdify() function.

 

 

-class sympy.printing.lambdarepr.LambdaPrinter(settings=None)[source]

+class sympy.printing.lambdarepr.LambdaPrinter(settings=None)[source]
 
This printer converts expressions into strings that can be used by
 lambdify.

 

@@ -3108,7 +3108,7 @@ 
Fortran Printing
 

-sympy.printing.lambdarepr.lambdarepr(expr, **settings)[source]

+sympy.printing.lambdarepr.lambdarepr(expr, **settings)[source]
 
Returns a string usable for lambdifying.

 

 
@@ -3126,7 +3126,7 @@ 
Fortran Printing
 

-class sympy.printing.latex.LatexPrinter(settings=None)[source]

+class sympy.printing.latex.LatexPrinter(settings=None)[source]
 

 

 printmethod: str = '_latex'

@@ -3134,7 +3134,7 @@ 
Fortran Printing
 

-parenthesize_super(s)[source]

+parenthesize_super(s)[source]
 
Protect superscripts in s

 
If the parenthesize_super option is set, protect with parentheses, else
 wrap in braces.

@@ -3437,7 +3437,7 @@ 
Fortran Printing
 

-sympy.printing.latex.print_latex(expr, **settings)[source]

+sympy.printing.latex.print_latex(expr, **settings)[source]
 
Prints LaTeX representation of the given expression. Takes the same
 settings as latex().

 

@@ -3449,12 +3449,12 @@ 
Fortran Printinghttps://www.w3.org/TR/MathML2

 

 

-class sympy.printing.mathml.MathMLPrinterBase(settings=None)[source]

+class sympy.printing.mathml.MathMLPrinterBase(settings=None)[source]
 
Contains common code required for MathMLContentPrinter and
 MathMLPresentationPrinter.

 

 

-doprint(expr)[source]

+doprint(expr)[source]
 
Prints the expression as MathML.

 

 
@@ -3462,7 +3462,7 @@ 
Fortran Printing
 

-class sympy.printing.mathml.MathMLContentPrinter(settings=None)[source]

+class sympy.printing.mathml.MathMLContentPrinter(settings=None)[source]
 
Prints an expression to the Content MathML markup language.

 
References: https://www.w3.org/TR/MathML2/chapter4.html

 

@@ -3472,7 +3472,7 @@ 
Fortran Printing
 

-mathml_tag(e)[source]

+mathml_tag(e)[source]
 
Returns the MathML tag for an expression.

 

 
@@ -3480,7 +3480,7 @@ 
Fortran Printing
 

-class sympy.printing.mathml.MathMLPresentationPrinter(settings=None)[source]

+class sympy.printing.mathml.MathMLPresentationPrinter(settings=None)[source]
 
Prints an expression to the Presentation MathML markup language.

 
References: https://www.w3.org/TR/MathML2/chapter3.html

 

@@ -3490,7 +3490,7 @@ 
Fortran Printing
 

-mathml_tag(e)[source]

+mathml_tag(e)[source]
 
Returns the MathML tag for an expression.

 

 
@@ -3527,7 +3527,7 @@ 
Fortran Printing
 

-sympy.printing.mathml.print_mathml(expr, printer='content', **settings)[source]

+sympy.printing.mathml.print_mathml(expr, printer='content', **settings)[source]
 
Prints a pretty representation of the MathML code for expr. If printer is
 presentation then prints Presentation MathML else prints content MathML.

 
Examples

@@ -3557,13 +3557,13 @@ 
Fortran Printing
 

-class sympy.printing.pycode.MpmathPrinter(settings=None)[source]

+class sympy.printing.pycode.MpmathPrinter(settings=None)[source]
 
Lambda printer for mpmath which maintains precision for floats

 

 
 

 

-sympy.printing.pycode.pycode(expr, **settings)[source]

+sympy.printing.pycode.pycode(expr, **settings)[source]
 
Converts an expr to a string of Python code

 

 
Parameters:

@@ -3625,7 +3625,7 @@ 
Fortran Printingstr() or print().

 

 

-class sympy.printing.repr.ReprPrinter(settings=None)[source]

+class sympy.printing.repr.ReprPrinter(settings=None)[source]
 

 

 printmethod: str = '_sympyrepr'

@@ -3633,13 +3633,13 @@ 
Fortran Printing
 

-emptyPrinter(expr)[source]

+emptyPrinter(expr)[source]
 
The fallback printer.

 

 
 

 

-reprify(args, sep)[source]

+reprify(args, sep)[source]
 
Prints each item in \(args\) and joins them with \(sep\).

 

 
@@ -3657,7 +3657,7 @@ 
Fortran Printing
 

-class sympy.printing.str.StrPrinter(settings=None)[source]

+class sympy.printing.str.StrPrinter(settings=None)[source]
 

 

 printmethod: str = '_sympystr'

@@ -3725,7 +3725,7 @@ 
Fortran Printing
 

-sympy.printing.tree.pprint_nodes(subtrees)[source]

+sympy.printing.tree.pprint_nodes(subtrees)[source]
 
Prettyprints systems of nodes.

 
Examples

 
>>> from sympy.printing.tree import pprint_nodes
@@ -3740,7 +3740,7 @@ 
Fortran Printing
 

-sympy.printing.tree.print_node(node, assumptions=True)[source]

+sympy.printing.tree.print_node(node, assumptions=True)[source]
 
Returns information about the “node”.

 
This includes class name, string representation and assumptions.

 

@@ -3755,7 +3755,7 @@ 
Fortran Printing
 

-sympy.printing.tree.tree(node, assumptions=True)[source]

+sympy.printing.tree.tree(node, assumptions=True)[source]
 
Returns a tree representation of “node” as a string.

 
It uses print_node() together with pprint_nodes() on node.args recursively.

 

@@ -3779,7 +3779,7 @@ 
Fortran Printing
 

-sympy.printing.tree.print_tree(node, assumptions=True)[source]

+sympy.printing.tree.print_tree(node, assumptions=True)[source]
 
Prints a tree representation of “node”.

 

 
Parameters:

@@ -3880,7 +3880,7 @@ 
Preview
**latex_settings,

 

 
-)[source]
+)[source]
 
View expression or LaTeX markup in PNG, DVI, PostScript or PDF form.

 
If the expr argument is an expression, it will be exported to LaTeX and
 then compiled using the available TeX distribution.  The first argument,
@@ -3979,7 +3979,7 @@ 
Preview
Implementation - Helper Classes/Functions

 

 

-sympy.printing.conventions.split_super_sub(text)[source]

+sympy.printing.conventions.split_super_sub(text)[source]
 
Split a symbol name into a name, superscripts and subscripts

 
The first part of the symbol name is considered to be its actual
 ‘name’, followed by super- and subscripts. Each superscript is
@@ -4003,7 +4003,7 @@ 
Preview¶
 easily translated to C or Fortran.

 

 

-class sympy.printing.codeprinter.CodePrinter(settings=None)[source]

+class sympy.printing.codeprinter.CodePrinter(settings=None)[source]
 
The base class for code-printing subclasses.

 

 

@@ -4012,7 +4012,7 @@ 
Preview

 

-doprint(expr, assign_to=None)[source]

+doprint(expr, assign_to=None)[source]

 
Print the expression as code.

 

 
Parameters:

@@ -4033,7 +4033,7 @@ 
Preview

 

-exception sympy.printing.codeprinter.AssignmentError[source]

+exception sympy.printing.codeprinter.AssignmentError[source]
 
Raised if an assignment variable for a loop is missing.

 

 
@@ -4065,7 +4065,7 @@ 
Preview

 

-sympy.printing.precedence.precedence(item)[source]

+sympy.printing.precedence.precedence(item)[source]
 
Returns the precedence of a given object.

 
This is the precedence for StrPrinter.

 

@@ -4076,38 +4076,38 @@ 
Preview
Pretty-Printing Implementation Helpers

 

 

-sympy.printing.pretty.pretty_symbology.U(name)[source]

+sympy.printing.pretty.pretty_symbology.U(name)[source]
 
Get a unicode character by name or, None if not found.

 
This exists because older versions of Python use older unicode databases.

 

 
 

 

-sympy.printing.pretty.pretty_symbology.pretty_use_unicode(flag=None)[source]

+sympy.printing.pretty.pretty_symbology.pretty_use_unicode(flag=None)[source]
 
Set whether pretty-printer should use unicode by default

 

 
 

 

-sympy.printing.pretty.pretty_symbology.pretty_try_use_unicode()[source]

+sympy.printing.pretty.pretty_symbology.pretty_try_use_unicode()[source]
 
See if unicode output is available and leverage it if possible

 

 
 

 

-sympy.printing.pretty.pretty_symbology.xstr(*args)[source]

+sympy.printing.pretty.pretty_symbology.xstr(*args)[source]
 

 
 
The following two functions return the Unicode version of the inputted Greek
 letter.

 

 

-sympy.printing.pretty.pretty_symbology.g(l)[source]

+sympy.printing.pretty.pretty_symbology.g(l)[source]
 

 
 

 

-sympy.printing.pretty.pretty_symbology.G(l)[source]

+sympy.printing.pretty.pretty_symbology.G(l)[source]
 

 
 

@@ -4143,21 +4143,21 @@ 
Preview
The following functions return Unicode vertical objects.

 

 

-sympy.printing.pretty.pretty_symbology.xobj(symb, length)[source]

+sympy.printing.pretty.pretty_symbology.xobj(symb, length)[source]
 
Construct spatial object of given length.

 
return: [] of equal-length strings

 

 
 

 

-sympy.printing.pretty.pretty_symbology.vobj(symb, height)[source]

+sympy.printing.pretty.pretty_symbology.vobj(symb, height)[source]
 
Construct vertical object of a given height

 
see: xobj

 

 
 

 

-sympy.printing.pretty.pretty_symbology.hobj(symb, width)[source]

+sympy.printing.pretty.pretty_symbology.hobj(symb, width)[source]
 
Construct horizontal object of a given width

 
see: xobj

 

@@ -4170,7 +4170,7 @@ 
Preview

 

-sympy.printing.pretty.pretty_symbology.VF(txt)[source]

+sympy.printing.pretty.pretty_symbology.VF(txt)[source]
 

 
 

@@ -4181,7 +4181,7 @@ 
Preview
The following constants/functions are for rendering atoms and symbols.

 

 

-sympy.printing.pretty.pretty_symbology.xsym(sym)[source]

+sympy.printing.pretty.pretty_symbology.xsym(sym)[source]
 
get symbology for a ‘character’

 

 
@@ -4192,19 +4192,19 @@ 
Preview

 

-sympy.printing.pretty.pretty_symbology.pretty_atom(atom_name, default=None, printer=None)[source]

+sympy.printing.pretty.pretty_symbology.pretty_atom(atom_name, default=None, printer=None)[source]
 
return pretty representation of an atom

 

 
 

 

-sympy.printing.pretty.pretty_symbology.pretty_symbol(symb_name, bold_name=False)[source]

+sympy.printing.pretty.pretty_symbology.pretty_symbol(symb_name, bold_name=False)[source]
 
return pretty representation of a symbol

 

 
 

 

-sympy.printing.pretty.pretty_symbology.annotated(letter)[source]

+sympy.printing.pretty.pretty_symbology.annotated(letter)[source]
 
Return a stylised drawing of the letter letter, together with
 information on how to put annotations (super- and subscripts to the
 left and to the right) on it.

@@ -4230,12 +4230,12 @@ 
Preview

 

 

-class sympy.printing.pretty.stringpict.stringPict(s, baseline=0)[source]

+class sympy.printing.pretty.stringpict.stringPict(s, baseline=0)[source]
 
An ASCII picture.
 The pictures are represented as a list of equal length strings.

 

 

-above(*args)[source]

+above(*args)[source]
 
Put pictures above this picture.
 Returns string, baseline arguments for stringPict.
 Baseline is baseline of bottom picture.

@@ -4243,7 +4243,7 @@ 
Preview

 

-below(*args)[source]

+below(*args)[source]
 
Put pictures under this picture.
 Returns string, baseline arguments for stringPict.
 Baseline is baseline of top picture

@@ -4260,26 +4260,26 @@ 
Preview

 

-height()[source]

+height()[source]
 
The height of the picture in characters.

 

 
 

 

-left(*args)[source]

+left(*args)[source]
 
Put pictures (left to right) at left.
 Returns string, baseline arguments for stringPict.

 

 
 

 

-leftslash()[source]

+leftslash()[source]
 
Precede object by a slash of the proper size.

 

 
 

 

-static next(*args)[source]

+static next(*args)[source]
 
Put a string of stringPicts next to each other.
 Returns string, baseline arguments for stringPict.

 

@@ -4294,7 +4294,7 @@ 
Preview
ifascii_nougly=False,

 

 
-)[source]
+)[source]
 
Put parentheses around self.
 Returns string, baseline arguments for stringPict.

 
left or right can be None or empty string which means ‘no paren from
@@ -4303,7 +4303,7 @@ 
Preview

 

-render(*args, **kwargs)[source]

+render(*args, **kwargs)[source]
 
Return the string form of self.

 
Unless the argument line_break is set to False, it will
 break the expression in a form that can be printed
@@ -4312,7 +4312,7 @@ 
Preview

 

-right(*args)[source]

+right(*args)[source]
 
Put pictures next to this one.
 Returns string, baseline arguments for stringPict.
 (Multiline) strings are allowed, and are given a baseline of 0.

@@ -4328,14 +4328,14 @@ 
Preview

 

-root(n=None)[source]

+root(n=None)[source]
 
Produce a nice root symbol.
 Produces ugly results for big n inserts.

 

 
 

 

-static stack(*args)[source]

+static stack(*args)[source]
 
Put pictures on top of each other,
 from top to bottom.
 Returns string, baseline arguments for stringPict.
@@ -4348,13 +4348,13 @@ 
Preview

 

-terminal_width()[source]

+terminal_width()[source]
 
Return the terminal width if possible, otherwise return 0.

 

 
 

 

-width()[source]

+width()[source]
 
The width of the picture in characters.

 

 
@@ -4362,7 +4362,7 @@ 
Preview

 

-class sympy.printing.pretty.stringpict.prettyForm(s, baseline=0, binding=0, unicode=None)[source]

+class sympy.printing.pretty.stringpict.prettyForm(s, baseline=0, binding=0, unicode=None)[source]
 
Extension of the stringPict class that knows about basic math applications,
 optimizing double minus signs.

 
“Binding” is interpreted as follows:

@@ -4380,7 +4380,7 @@ 
Preview

 

 

-static apply(function, *args)[source]

+static apply(function, *args)[source]
 
Functions of one or more variables.

 

 
@@ -4407,7 +4407,7 @@ 
dotprint
 
**kwargs,

 

 
-)[source]
+)[source]
 
DOT description of a SymPy expression tree

 

 
Parameters:

diff --git a/dev/modules/rewriting.html b/dev/modules/rewriting.html
index 76b07c3ccca..ee42d00370b 100644
--- a/dev/modules/rewriting.html
+++ b/dev/modules/rewriting.html
@@ -914,7 +914,7 @@ 
Common Subexpression Detection and Collectionlist=True,

 

 
-)[source]
+)[source]
 
Perform common subexpression elimination on an expression.

 

 
Parameters:

diff --git a/dev/modules/series/formal.html b/dev/modules/series/formal.html
index 7fcab8d8b49..e2dbb1ead2f 100644
--- a/dev/modules/series/formal.html
+++ b/dev/modules/series/formal.html
@@ -803,7 +803,7 @@ 
Formal Power Series
 

-class sympy.series.formal.FormalPowerSeries(*args)[source]

+class sympy.series.formal.FormalPowerSeries(*args)[source]
 
Represents Formal Power Series of a function.

 
Explanation

 
No computation is performed. This class should only to be used to represent
@@ -815,7 +815,7 @@ 
Formal Power Series
 

-coeff_bell(n)[source]

+coeff_bell(n)[source]
 
self.coeff_bell(n) returns a sequence of Bell polynomials of the second kind.
 Note that n should be a integer.

 
The second kind of Bell polynomials (are sometimes called “partial” Bell
@@ -841,7 +841,7 @@ 
Formal Power Series
 

-compose(other, x=None, n=6)[source]

+compose(other, x=None, n=6)[source]
 
Returns the truncated terms of the formal power series of the composed function,
 up to specified n.

 

@@ -897,7 +897,7 @@ 
Formal Power Series
 

-integrate(x=None, **kwargs)[source]

+integrate(x=None, **kwargs)[source]
 
Integrate Formal Power Series.

 
Examples

 
>>> from sympy import fps, sin, integrate
@@ -913,7 +913,7 @@ 
Formal Power Series
 

-inverse(x=None, n=6)[source]

+inverse(x=None, n=6)[source]
 
Returns the truncated terms of the inverse of the formal power series,
 up to specified n.

 

@@ -963,7 +963,7 @@ 
Formal Power Series
 

-polynomial(n=6)[source]

+polynomial(n=6)[source]
 
Truncated series as polynomial.

 
Explanation

 
Returns series expansion of f upto order O(x**n)
@@ -972,7 +972,7 @@ 
Formal Power Series
 

-product(other, x=None, n=6)[source]

+product(other, x=None, n=6)[source]
 
Multiplies two Formal Power Series, using discrete convolution and
 return the truncated terms upto specified order.

 

@@ -1003,7 +1003,7 @@ 
Formal Power Series
 

-truncate(n=6)[source]

+truncate(n=6)[source]
 
Truncated series.

 
Explanation

 
Returns truncated series expansion of f upto
@@ -1028,7 +1028,7 @@ 
Formal Power Seriesfull=False,

 

 
-)[source]
+)[source]
 
Generates Formal Power Series of f.

 

 
Parameters:

@@ -1116,7 +1116,7 @@ 
Formal Power Seriesfull=False,

 

 
-)[source]
+)[source]
 
Computes the formula for Formal Power Series of a function.

 

 
Parameters:

@@ -1186,7 +1186,7 @@ 
Formal Power Series
 

-class sympy.series.formal.FormalPowerSeriesCompose(*args)[source]

+class sympy.series.formal.FormalPowerSeriesCompose(*args)[source]
 
Represents the composed formal power series of two functions.

 
Explanation

 
No computation is performed. Terms are calculated using a term by term logic,
@@ -1211,7 +1211,7 @@ 
Formal Power Series
 

-class sympy.series.formal.FormalPowerSeriesInverse(*args)[source]

+class sympy.series.formal.FormalPowerSeriesInverse(*args)[source]
 
Represents the Inverse of a formal power series.

 
Explanation

 
No computation is performed. Terms are calculated using a term by term logic,
@@ -1234,7 +1234,7 @@ 
Formal Power Series
 

-class sympy.series.formal.FormalPowerSeriesProduct(*args)[source]

+class sympy.series.formal.FormalPowerSeriesProduct(*args)[source]
 
Represents the product of two formal power series of two functions.

 
Explanation

 
No computation is performed. Terms are calculated using a term by term logic,
@@ -1257,7 +1257,7 @@ 
Formal Power Series
 

-class sympy.series.formal.FiniteFormalPowerSeries(*args)[source]

+class sympy.series.formal.FiniteFormalPowerSeries(*args)[source]
 
Base Class for Product, Compose and Inverse classes

 

 
@@ -1265,7 +1265,7 @@ 
Formal Power Series

 

 

-sympy.series.formal.rational_independent(terms, x)[source]

+sympy.series.formal.rational_independent(terms, x)[source]
 
Returns a list of all the rationally independent terms.

 
Examples

 
>>> from sympy import sin, cos
@@ -1283,7 +1283,7 @@ 
Rational Algorithm
 

-sympy.series.formal.rational_algorithm(f, x, k, order=4, full=False)[source]

+sympy.series.formal.rational_algorithm(f, x, k, order=4, full=False)[source]
 
Rational algorithm for computing
 formula of coefficients of Formal Power Series
 of a function.

@@ -1359,7 +1359,7 @@ 
Rational Algorithm

 

 

-sympy.series.formal.simpleDE(f, x, g, order=4)[source]

+sympy.series.formal.simpleDE(f, x, g, order=4)[source]
 
Generates simple DE.

 
Explanation

 
DE is of the form

@@ -1375,7 +1375,7 @@ 
Hypergeometric Algorithm
 

-sympy.series.formal.exp_re(DE, r, k)[source]

+sympy.series.formal.exp_re(DE, r, k)[source]
 
Converts a DE with constant coefficients (explike) into a RE.

 
Explanation

 
Performs the substitution:

@@ -1405,7 +1405,7 @@ 
Hypergeometric Algorithm
 

-sympy.series.formal.hyper_re(DE, r, k)[source]

+sympy.series.formal.hyper_re(DE, r, k)[source]
 
Converts a DE into a RE.

 
Explanation

 
Performs the substitution:

@@ -1435,7 +1435,7 @@ 
Hypergeometric Algorithm
 

-sympy.series.formal.rsolve_hypergeometric(f, x, P, Q, k, m)[source]

+sympy.series.formal.rsolve_hypergeometric(f, x, P, Q, k, m)[source]
 
Solves RE of hypergeometric type.

 

 
Returns:

@@ -1491,7 +1491,7 @@ 
Hypergeometric Algorithm
 

-sympy.series.formal.solve_de(f, x, DE, order, g, k)[source]

+sympy.series.formal.solve_de(f, x, DE, order, g, k)[source]
 
Solves the DE.

 

 
Returns:

@@ -1527,7 +1527,7 @@ 
Hypergeometric Algorithm
 

-sympy.series.formal.hyper_algorithm(f, x, k, order=4)[source]

+sympy.series.formal.hyper_algorithm(f, x, k, order=4)[source]
 
Hypergeometric algorithm for computing Formal Power Series.

 
Explanation

 

diff --git a/dev/modules/series/fourier.html b/dev/modules/series/fourier.html
index e7f096c73bc..c742b73a12c 100644
--- a/dev/modules/series/fourier.html
+++ b/dev/modules/series/fourier.html
@@ -803,7 +803,7 @@ 
Fourier Series
 

-class sympy.series.fourier.FourierSeries(*args)[source]

+class sympy.series.fourier.FourierSeries(*args)[source]
 
Represents Fourier sine/cosine series.

 
Explanation

 
This class only represents a fourier series.
@@ -816,7 +816,7 @@ 
Fourier Series
 

-scale(s)[source]

+scale(s)[source]
 
Scale the function by a term independent of x.

 
Explanation

 
f(x) -> s * f(x)

@@ -834,7 +834,7 @@ 
Fourier Series
 

-scalex(s)[source]

+scalex(s)[source]
 
Scale x by a term independent of x.

 
Explanation

 
f(x) -> f(s*x)

@@ -852,7 +852,7 @@ 
Fourier Series
 

-shift(s)[source]

+shift(s)[source]
 
Shift the function by a term independent of x.

 
Explanation

 
f(x) -> f(x) + s

@@ -870,7 +870,7 @@ 
Fourier Series
 

-shiftx(s)[source]

+shiftx(s)[source]
 
Shift x by a term independent of x.

 
Explanation

 
f(x) -> f(x + s)

@@ -888,7 +888,7 @@ 
Fourier Series
 

-sigma_approximation(n=3)[source]

+sigma_approximation(n=3)[source]
 
Return \(\sigma\)-approximation of Fourier series with respect
 to order n.

 

@@ -955,7 +955,7 @@ 
Fourier Series
 

-truncate(n=3)[source]

+truncate(n=3)[source]
 
Return the first n nonzero terms of the series.

 
If n is None return an iterator.

 

@@ -990,7 +990,7 @@ 
Fourier Series
 

-sympy.series.fourier.fourier_series(f, limits=None, finite=True)[source]

+sympy.series.fourier.fourier_series(f, limits=None, finite=True)[source]
 
Computes the Fourier trigonometric series expansion.

 

 
Parameters:

diff --git a/dev/modules/series/limitseq.html b/dev/modules/series/limitseq.html
index 69b3701d236..4f3d5a64de0 100644
--- a/dev/modules/series/limitseq.html
+++ b/dev/modules/series/limitseq.html
@@ -803,7 +803,7 @@ 
Limits of Sequences
 

-sympy.series.limitseq.difference_delta(expr, n=None, step=1)[source]

+sympy.series.limitseq.difference_delta(expr, n=None, step=1)[source]
 
Difference Operator.

 
Explanation

 
Discrete analog of differential operator. Given a sequence x[n],
@@ -828,7 +828,7 @@ 
Limits of Sequences
 

-sympy.series.limitseq.dominant(expr, n)[source]

+sympy.series.limitseq.dominant(expr, n)[source]
 
Finds the dominant term in a sum, that is a term that dominates
 every other term.

 
Explanation

@@ -854,7 +854,7 @@ 
Limits of Sequences
 

-sympy.series.limitseq.limit_seq(expr, n=None, trials=5)[source]

+sympy.series.limitseq.limit_seq(expr, n=None, trials=5)[source]
 
Finds the limit of a sequence as index n tends to infinity.

 

 
Parameters:

diff --git a/dev/modules/series/sequences.html b/dev/modules/series/sequences.html
index bcfdd950b83..88bf888f188 100644
--- a/dev/modules/series/sequences.html
+++ b/dev/modules/series/sequences.html
@@ -803,7 +803,7 @@ 
Sequences
 

-sympy.series.sequences.sequence(seq, limits=None)[source]

+sympy.series.sequences.sequence(seq, limits=None)[source]
 
Returns appropriate sequence object.

 
Explanation

 
If seq is a SymPy sequence, returns SeqPer object
@@ -827,17 +827,17 @@ 
Sequences

 

 

-class sympy.series.sequences.SeqBase(*args)[source]

+class sympy.series.sequences.SeqBase(*args)[source]
 
Base class for sequences

 

 

-coeff(pt)[source]

+coeff(pt)[source]
 
Returns the coefficient at point pt

 

 
 

 

-coeff_mul(other)[source]

+coeff_mul(other)[source]
 
Should be used when other is not a sequence. Should be
 defined to define custom behaviour.

 
Examples

@@ -861,7 +861,7 @@ 
Sequences Basegfvar=None,

 

 
-)[source]
+)[source]
 
Finds the shortest linear recurrence that satisfies the first n
 terms of sequence of order \(\leq\) n/2 if possible.
 If d is specified, find shortest linear recurrence of order
@@ -951,7 +951,7 @@ 
Sequences Base

 

 

-class sympy.series.sequences.SeqFormula(formula, limits=None)[source]

+class sympy.series.sequences.SeqFormula(formula, limits=None)[source]
 
Represents sequence based on a formula.

 
Elements are generated using a formula.

 
Examples

@@ -988,7 +988,7 @@ 
Elementary Sequences
 

 

-coeff_mul(coeff)[source]

+coeff_mul(coeff)[source]
 
See docstring of SeqBase.coeff_mul

 

 
@@ -996,7 +996,7 @@ 
Elementary Sequences
 

-class sympy.series.sequences.SeqPer(periodical, limits=None)[source]

+class sympy.series.sequences.SeqPer(periodical, limits=None)[source]
 
Represents a periodic sequence.

 
The elements are repeated after a given period.

 
Examples

@@ -1042,7 +1042,7 @@ 
Elementary Sequences
 

 

-coeff_mul(coeff)[source]

+coeff_mul(coeff)[source]
 
See docstring of SeqBase.coeff_mul

 

 
@@ -1053,7 +1053,7 @@ 
Elementary SequencesSingleton Sequences

 

 

-class sympy.series.sequences.EmptySequence[source]

+class sympy.series.sequences.EmptySequence[source]
 
Represents an empty sequence.

 
The empty sequence is also available as a singleton as
 S.EmptySequence.

@@ -1072,7 +1072,7 @@ 
Singleton Sequences
 

-coeff_mul(coeff)[source]

+coeff_mul(coeff)[source]
 
See docstring of SeqBase.coeff_mul

 

 
@@ -1083,7 +1083,7 @@ 
Singleton Sequences

 

 

-class sympy.series.sequences.SeqAdd(*args, **kwargs)[source]

+class sympy.series.sequences.SeqAdd(*args, **kwargs)[source]
 
Represents term-wise addition of sequences.

 

 
Rules:

 
-)[source]
+)[source]
 
A finite degree recursive sequence.

 

 
Parameters:

diff --git a/dev/modules/series/series.html b/dev/modules/series/series.html
index 23121806744..3d486463fa7 100644
--- a/dev/modules/series/series.html
+++ b/dev/modules/series/series.html
@@ -805,7 +805,7 @@ 
LimitsThe main purpose of this module is the computation of limits.

 

 

-sympy.series.limits.limit(e, z, z0, dir='+')[source]

+sympy.series.limits.limit(e, z, z0, dir='+')[source]
 
Computes the limit of e(z) at the point z0.

 

 
Parameters:

@@ -859,7 +859,7 @@ 
Limits
 

-class sympy.series.limits.Limit(e, z, z0, dir='+')[source]

+class sympy.series.limits.Limit(e, z, z0, dir='+')[source]
 
Represents an unevaluated limit.

 
Examples

 
>>> from sympy import Limit, sin
@@ -872,7 +872,7 @@ 
Limits
 

 

-doit(**hints)[source]

+doit(**hints)[source]
 
Evaluates the limit.

 

 
Parameters:

@@ -968,7 +968,7 @@ 
Notes
 
Reference

 

 

-sympy.series.gruntz.gruntz(e, z, z0, dir='+')[source]

+sympy.series.gruntz.gruntz(e, z, z0, dir='+')[source]
 
Compute the limit of e(z) at the point z0 using the Gruntz algorithm.

 
Explanation

 
z0 can be any expression, including oo and -oo.

@@ -982,13 +982,13 @@ 
Reference
 

-sympy.series.gruntz.compare(a, b, x)[source]

+sympy.series.gruntz.compare(a, b, x)[source]
 
Returns “<” if a<b, “=” for a == b, “>” for a>b

 

 
 

 

-sympy.series.gruntz.rewrite(e, Omega, x, wsym)[source]

+sympy.series.gruntz.rewrite(e, Omega, x, wsym)[source]
 
e(x) … the function
 Omega … the mrv set
 wsym … the symbol which is going to be used for w

@@ -998,7 +998,7 @@ 
Reference
 

-sympy.series.gruntz.build_expression_tree(Omega, rewrites)[source]

+sympy.series.gruntz.build_expression_tree(Omega, rewrites)[source]
 
Helper function for rewrite.

 
We need to sort Omega (mrv set) so that we replace an expression before
 we replace any expression in terms of which it has to be rewritten:

@@ -1014,26 +1014,26 @@ 
Reference
 

-sympy.series.gruntz.mrv_leadterm(e, x)[source]

+sympy.series.gruntz.mrv_leadterm(e, x)[source]
 
Returns (c0, e0) for e.

 

 
 

 

-sympy.series.gruntz.calculate_series(e, x, logx=None)[source]

+sympy.series.gruntz.calculate_series(e, x, logx=None)[source]
 
Calculates at least one term of the series of e in x.

 
This is a place that fails most often, so it is in its own function.

 

 
 

 

-sympy.series.gruntz.limitinf(e, x)[source]

+sympy.series.gruntz.limitinf(e, x)[source]
 
Limit e(x) for x-> oo.

 

 
 

 

-sympy.series.gruntz.sign(e, x)[source]

+sympy.series.gruntz.sign(e, x)[source]
 
Returns a sign of an expression e(x) for x->oo.

 
e >  0 for x sufficiently large ...  1
 e == 0 for x sufficiently large ...  0
@@ -1049,14 +1049,14 @@ 
Reference
 

-sympy.series.gruntz.mrv(e, x)[source]

+sympy.series.gruntz.mrv(e, x)[source]
 
Returns a SubsSet of most rapidly varying (mrv) subexpressions of ‘e’,
 and e rewritten in terms of these

 

 
 

 

-sympy.series.gruntz.mrv_max1(f, g, exps, x)[source]

+sympy.series.gruntz.mrv_max1(f, g, exps, x)[source]
 
Computes the maximum of two sets of expressions f and g, which
 are in the same comparability class, i.e. mrv_max1() compares (two elements of)
 f and g and returns the set, which is in the higher comparability class
@@ -1066,7 +1066,7 @@ 
Reference
 

-sympy.series.gruntz.mrv_max3(f, expsf, g, expsg, union, expsboth, x)[source]

+sympy.series.gruntz.mrv_max3(f, expsf, g, expsg, union, expsboth, x)[source]
 
Computes the maximum of two sets of expressions f and g, which
 are in the same comparability class, i.e. max() compares (two elements of)
 f and g and returns either (f, expsf) [if f is larger], (g, expsg)
@@ -1075,7 +1075,7 @@ 
Reference
 

-class sympy.series.gruntz.SubsSet[source]

+class sympy.series.gruntz.SubsSet[source]
 
Stores (expr, dummy) pairs, and how to rewrite expr-s.

 
Explanation

 
The gruntz algorithm needs to rewrite certain expressions in term of a new
@@ -1119,25 +1119,25 @@ 
Reference
 

-copy()[source]

+copy()[source]
 
Create a shallow copy of SubsSet

 

 
 

 

-do_subs(e)[source]

+do_subs(e)[source]
 
Substitute the variables with expressions

 

 
 

 

-meets(s2)[source]

+meets(s2)[source]
 
Tell whether or not self and s2 have non-empty intersection

 

 
 

 

-union(s2, exps=None)[source]

+union(s2, exps=None)[source]
 
Compute the union of self and s2, adjusting exps

 

 
@@ -1164,7 +1164,7 @@ 
Examples
 
Reference

 

 

-sympy.series.series.series(expr, x=None, x0=0, n=6, dir='+')[source]

+sympy.series.series.series(expr, x=None, x0=0, n=6, dir='+')[source]
 
Series expansion of expr around point \(x = x0\).

 

 
Parameters:

@@ -1253,7 +1253,7 @@ 
ExamplesReference

 

 

-class sympy.series.order.Order(expr, *args, **kwargs)[source]

+class sympy.series.order.Order(expr, *args, **kwargs)[source]
 
Represents the limiting behavior of some function.

 
Explanation

 
The order of a function characterizes the function based on the limiting
@@ -1361,7 +1361,7 @@ 
Reference
 

 

-contains(expr)[source]

+contains(expr)[source]
 
Return True if expr belongs to Order(self.expr, *self.variables).
 Return False if self belongs to expr.
 Return None if the inclusion relation cannot be determined
@@ -1379,7 +1379,7 @@ 
Series Acceleration

 

 

-sympy.series.acceleration.richardson(A, k, n, N)[source]

+sympy.series.acceleration.richardson(A, k, n, N)[source]
 
Calculate an approximation for lim k->oo A(k) using Richardson
 extrapolation with the terms A(n), A(n+1), …, A(n+N+1).
 Choosing N ~= 2*n often gives good results.

@@ -1425,7 +1425,7 @@ 
Reference
 

-sympy.series.acceleration.shanks(A, k, n, m=1)[source]

+sympy.series.acceleration.shanks(A, k, n, m=1)[source]
 
Calculate an approximation for lim k->oo A(k) using the n-term Shanks
 transformation S(A)(n). With m > 1, calculate the m-fold recursive
 Shanks transformation S(S(…S(A)…))(n).

@@ -1455,7 +1455,7 @@ 
Residues
 
Reference

 

 

-sympy.series.residues.residue(expr, x, x0)[source]

+sympy.series.residues.residue(expr, x, x0)[source]
 
Finds the residue of expr at the point x=x0.

 
The residue is defined as the coefficient of 1/(x-x0) in the power series
 expansion about x=x0.

diff --git a/dev/modules/sets.html b/dev/modules/sets.html
index ca3fc8b05fa..990599c0d5a 100644
--- a/dev/modules/sets.html
+++ b/dev/modules/sets.html
@@ -804,7 +804,7 @@ 
Documentation Version

 
Basic Sets

 

 

-class sympy.sets.sets.Set(*args)[source]

+class sympy.sets.sets.Set(*args)[source]
 
The base class for any kind of set.

 
Explanation

 
This is not meant to be used directly as a container of items. It does not
@@ -857,7 +857,7 @@ 
Documentation Version

 
 

 

-complement(universe)[source]

+complement(universe)[source]
 
The complement of ‘self’ w.r.t the given universe.

 
Examples

 
>>> from sympy import Interval, S
@@ -873,7 +873,7 @@ 
Documentation Version

 
 

 

-contains(other)[source]

+contains(other)[source]
 
Returns a SymPy value indicating whether other is contained
 in self: true if it is, false if it is not, else
 an unevaluated Contains expression (or, as in the case of
@@ -940,7 +940,7 @@ 
Documentation Version

 
 

 

-intersect(other)[source]

+intersect(other)[source]
 
Returns the intersection of ‘self’ and ‘other’.

 
Examples

 
>>> from sympy import Interval
@@ -961,7 +961,7 @@ 
Documentation Version

 
 

 

-intersection(other)[source]

+intersection(other)[source]
 
Alias for intersect()

 

 
@@ -983,7 +983,7 @@ 
Documentation Version

 
 

 

-is_disjoint(other)[source]

+is_disjoint(other)[source]
 
Returns True if self and other are disjoint.

 
Examples

 
>>> from sympy import Interval
@@ -1023,7 +1023,7 @@ 
Documentation Version

 
 

 

-is_proper_subset(other)[source]

+is_proper_subset(other)[source]
 
Returns True if self is a proper subset of other.

 
Examples

 
>>> from sympy import Interval
@@ -1037,7 +1037,7 @@ 
Documentation Version

 
 

 

-is_proper_superset(other)[source]

+is_proper_superset(other)[source]
 
Returns True if self is a proper superset of other.

 
Examples

 
>>> from sympy import Interval
@@ -1051,7 +1051,7 @@ 
Documentation Version

 
 

 

-is_subset(other)[source]

+is_subset(other)[source]
 
Returns True if self is a subset of other.

 
Examples

 
>>> from sympy import Interval
@@ -1065,7 +1065,7 @@ 
Documentation Version

 
 

 

-is_superset(other)[source]

+is_superset(other)[source]
 
Returns True if self is a superset of other.

 
Examples

 
>>> from sympy import Interval
@@ -1079,19 +1079,19 @@ 
Documentation Version

 
 

 

-isdisjoint(other)[source]

+isdisjoint(other)[source]
 
Alias for is_disjoint()

 

 
 

 

-issubset(other)[source]

+issubset(other)[source]
 
Alias for is_subset()

 

 
 

 

-issuperset(other)[source]

+issuperset(other)[source]
 
Alias for is_superset()

 

 
@@ -1171,7 +1171,7 @@ 
Documentation Version

 
 

 

-powerset()[source]

+powerset()[source]
 
Find the Power set of self.

 
Examples

 
>>> from sympy import EmptySet, FiniteSet, Interval
@@ -1220,7 +1220,7 @@ 
Documentation Version

 
 

 

-symmetric_difference(other)[source]

+symmetric_difference(other)[source]
 
Returns symmetric difference of self and other.

 
Examples

 
>>> from sympy import Interval, S
@@ -1246,7 +1246,7 @@ 
Documentation Version

 
 

 

-union(other)[source]

+union(other)[source]
 
Returns the union of self and other.

 
Examples

 
As a shortcut it is possible to use the + operator:

@@ -1272,7 +1272,7 @@ 
Documentation Version

 
 

 

-sympy.sets.sets.imageset(*args)[source]

+sympy.sets.sets.imageset(*args)[source]
 
Return an image of the set under transformation f.

 
Explanation

 
If this function cannot compute the image, it returns an
@@ -1332,7 +1332,7 @@ 
Elementary Setsright_open=False,

 

 
-)[source]
+)[source]
 
Represents a real interval as a Set.

 

 
Usage:
Returns an interval with end points start and end.

@@ -1376,19 +1376,19 @@ 
Elementary Sets
 

-classmethod Lopen(a, b)[source]

+classmethod Lopen(a, b)[source]
 
Return an interval not including the left boundary.

 

 
 

 

-classmethod Ropen(a, b)[source]

+classmethod Ropen(a, b)[source]
 
Return an interval not including the right boundary.

 

 
 

 

-as_relational(x)[source]

+as_relational(x)[source]
 
Rewrite an interval in terms of inequalities and logic operators.

 

 
@@ -1433,7 +1433,7 @@ 
Elementary Sets
 

-classmethod open(a, b)[source]

+classmethod open(a, b)[source]
 
Return an interval including neither boundary.

 

 
@@ -1468,7 +1468,7 @@ 
Elementary Sets
 

-class sympy.sets.sets.FiniteSet(*args, **kwargs)[source]

+class sympy.sets.sets.FiniteSet(*args, **kwargs)[source]
 
Represents a finite set of Sympy expressions.

 
Examples

 
>>> from sympy import FiniteSet, Symbol, Interval, Naturals0
@@ -1499,7 +1499,7 @@ 
Elementary Sets
 

-as_relational(symbol)[source]

+as_relational(symbol)[source]
 
Rewrite a FiniteSet in terms of equalities and logic operators.

 

 
@@ -1510,7 +1510,7 @@ 
Elementary Sets

 

 

-class sympy.sets.sets.Union(*args, **kwargs)[source]

+class sympy.sets.sets.Union(*args, **kwargs)[source]
 
Represents a union of sets as a Set.

 
Examples

 
>>> from sympy import Union, Interval
@@ -1537,7 +1537,7 @@ 
Compound Sets
 

-as_relational(symbol)[source]

+as_relational(symbol)[source]
 
Rewrite a Union in terms of equalities and logic operators.

 

 
@@ -1545,7 +1545,7 @@ 
Compound Sets
 

-class sympy.sets.sets.Intersection(*args, evaluate=None)[source]

+class sympy.sets.sets.Intersection(*args, evaluate=None)[source]
 
Represents an intersection of sets as a Set.

 
Examples

 
>>> from sympy import Intersection, Interval
@@ -1571,7 +1571,7 @@ 
Compound Sets
 

-as_relational(symbol)[source]

+as_relational(symbol)[source]
 
Rewrite an Intersection in terms of equalities and logic operators

 

 
@@ -1579,7 +1579,7 @@ 
Compound Sets
 

-class sympy.sets.sets.ProductSet(*sets, **assumptions)[source]

+class sympy.sets.sets.ProductSet(*sets, **assumptions)[source]
 
Represents a Cartesian Product of Sets.

 
Explanation

 
Returns a Cartesian product given several sets as either an iterable
@@ -1644,7 +1644,7 @@ 
Compound Sets
 

-class sympy.sets.sets.Complement(a, b, evaluate=True)[source]

+class sympy.sets.sets.Complement(a, b, evaluate=True)[source]
 
Represents the set difference or relative complement of a set with
 another set.

 

@@ -1671,14 +1671,14 @@ 
Compound Sets
 

-as_relational(symbol)[source]

+as_relational(symbol)[source]
 
Rewrite a complement in terms of equalities and logic
 operators

 

 
 

 

-static reduce(A, B)[source]

+static reduce(A, B)[source]
 
Simplify a Complement.

 

 
@@ -1686,7 +1686,7 @@ 
Compound Sets
 

-class sympy.sets.sets.SymmetricDifference(a, b, evaluate=True)[source]

+class sympy.sets.sets.SymmetricDifference(a, b, evaluate=True)[source]
 
Represents the set of elements which are in either of the
 sets and not in their intersection.

 
Examples

@@ -1708,7 +1708,7 @@ 
Compound Sets
 

-as_relational(symbol)[source]

+as_relational(symbol)[source]
 
Rewrite a symmetric_difference in terms of equalities and
 logic operators

 

@@ -1717,7 +1717,7 @@ 
Compound Sets
 

-class sympy.sets.sets.DisjointUnion(*sets)[source]

+class sympy.sets.sets.DisjointUnion(*sets)[source]
 
Represents the disjoint union (also known as the external disjoint union)
 of a finite number of sets.

 
Examples

@@ -1744,7 +1744,7 @@ 
Compound Sets

 

 

-class sympy.sets.sets.EmptySet[source]

+class sympy.sets.sets.EmptySet[source]
 
Represents the empty set. The empty set is available as a singleton
 as S.EmptySet.

 
Examples

@@ -1772,7 +1772,7 @@ 
Singleton Sets
 

-class sympy.sets.sets.UniversalSet[source]

+class sympy.sets.sets.UniversalSet[source]
 
Represents the set of all things.
 The universal set is available as a singleton as S.UniversalSet.

 
Examples

@@ -1803,7 +1803,7 @@ 
Singleton Sets
Special Sets

 

 

-class sympy.sets.fancysets.Rationals[source]

+class sympy.sets.fancysets.Rationals[source]
 
Represents the rational numbers. This set is also available as
 the singleton S.Rationals.

 
Examples

@@ -1819,7 +1819,7 @@ 
Singleton Sets
 

-class sympy.sets.fancysets.Naturals[source]

+class sympy.sets.fancysets.Naturals[source]
 
Represents the natural numbers (or counting numbers) which are all
 positive integers starting from 1. This set is also available as
 the singleton S.Naturals.

@@ -1851,7 +1851,7 @@ 
Singleton Sets
 

-class sympy.sets.fancysets.Naturals0[source]

+class sympy.sets.fancysets.Naturals0[source]
 
Represents the whole numbers which are all the non-negative integers,
 inclusive of zero.

 

@@ -1867,7 +1867,7 @@ 
Singleton Sets
 

-class sympy.sets.fancysets.Integers[source]

+class sympy.sets.fancysets.Integers[source]
 
Represents all integers: positive, negative and zero. This set is also
 available as the singleton S.Integers.

 
Examples

@@ -1902,7 +1902,7 @@ 
Singleton Sets
 

-class sympy.sets.fancysets.Reals[source]

+class sympy.sets.fancysets.Reals[source]
 
Represents all real numbers
 from negative infinity to positive infinity,
 including all integer, rational and irrational numbers.
@@ -1929,7 +1929,7 @@ 
Singleton Sets
 

-class sympy.sets.fancysets.Complexes[source]

+class sympy.sets.fancysets.Complexes[source]
 
The Set of all complex numbers

 
Examples

 
>>> from sympy import S, I
@@ -1947,7 +1947,7 @@ 
Singleton Sets
 

-class sympy.sets.fancysets.ImageSet(flambda, *sets)[source]

+class sympy.sets.fancysets.ImageSet(flambda, *sets)[source]
 
Image of a set under a mathematical function. The transformation
 must be given as a Lambda function which has as many arguments
 as the elements of the set upon which it operates, e.g. 1 argument
@@ -2005,7 +2005,7 @@ 
Singleton Sets
 

-class sympy.sets.fancysets.Range(*args)[source]

+class sympy.sets.fancysets.Range(*args)[source]
 
Represents a range of integers. Can be called as Range(stop),
 Range(start, stop), or Range(start, stop, step); when step is
 not given it defaults to 1.

@@ -2087,7 +2087,7 @@ 
Singleton Sets
 

-as_relational(x)[source]

+as_relational(x)[source]
 
Rewrite a Range in terms of equalities and logic operators.

 

 
@@ -2107,7 +2107,7 @@ 
Singleton Sets
 

-class sympy.sets.fancysets.ComplexRegion(sets, polar=False)[source]

+class sympy.sets.fancysets.ComplexRegion(sets, polar=False)[source]
 
Represents the Set of all Complex Numbers. It can represent a
 region of Complex Plane in both the standard forms Polar and
 Rectangular coordinates.

@@ -2235,7 +2235,7 @@ 
Singleton Sets
 

-classmethod from_real(sets)[source]

+classmethod from_real(sets)[source]
 
Converts given subset of real numbers to a complex region.

 
Examples

 
>>> from sympy import Interval, ComplexRegion
@@ -2288,7 +2288,7 @@ 
Singleton Sets
 

-class sympy.sets.fancysets.CartesianComplexRegion(sets)[source]

+class sympy.sets.fancysets.CartesianComplexRegion(sets)[source]
 
Set representing a square region of the complex plane.

 

 

@@ -2311,7 +2311,7 @@ 
Singleton Sets
 

-class sympy.sets.fancysets.PolarComplexRegion(sets)[source]

+class sympy.sets.fancysets.PolarComplexRegion(sets)[source]
 
Set representing a polar region of the complex plane.

 

 

@@ -2336,7 +2336,7 @@ 
Singleton Sets
 

-sympy.sets.fancysets.normalize_theta_set(theta)[source]

+sympy.sets.fancysets.normalize_theta_set(theta)[source]
 
Normalize a Real Set \(theta\) in the interval \([0, 2\pi)\). It returns
 a normalized value of theta in the Set. For Interval, a maximum of
 one cycle \([0, 2\pi]\), is returned i.e. for theta equal to \([0, 10\pi]\),
@@ -2383,7 +2383,7 @@ 
Singleton Sets
Power sets

 

 

-class sympy.sets.powerset.PowerSet(arg, evaluate=None)[source]

+class sympy.sets.powerset.PowerSet(arg, evaluate=None)[source]
 
A symbolic object representing a power set.

 

 
Parameters:

@@ -2457,7 +2457,7 @@ 
Singleton Setsbase_set=UniversalSet,

 

 
-)[source]
+)[source]
 
Set of elements which satisfies a given condition.

 

 

@@ -2527,7 +2527,7 @@ 
Singleton Sets
 

-class sympy.sets.conditionset.Contains(x, s, evaluate=None)[source]

+class sympy.sets.conditionset.Contains(x, s, evaluate=None)[source]
 
Asserts that x is an element of the set S.

 
Examples

 
>>> from sympy import Symbol, Integer, S, Contains
@@ -2554,7 +2554,7 @@ 
Singleton Sets

 

 

-class sympy.sets.conditionset.SetKind(element_kind=None)[source]

+class sympy.sets.conditionset.SetKind(element_kind=None)[source]
 
SetKind is kind for all Sets

 
Every instance of Set will have kind SetKind parametrised by the kind
 of the elements of the Set. The kind of the elements might be
diff --git a/dev/modules/simplify/fu.html b/dev/modules/simplify/fu.html
index 09d10579e26..99f24dde7e0 100644
--- a/dev/modules/simplify/fu.html
+++ b/dev/modules/simplify/fu.html
@@ -969,14 +969,14 @@ 
Documentation Version

 
Rules

 

 

-sympy.simplify.fu.TR0(rv)[source]

+sympy.simplify.fu.TR0(rv)[source]
 
Simplification of rational polynomials, trying to simplify
 the expression, e.g. combine things like 3*x + 2*x, etc….

 

 
 

 

-sympy.simplify.fu.TR1(rv)[source]

+sympy.simplify.fu.TR1(rv)[source]
 
Replace sec, csc with 1/cos, 1/sin

 
Examples

 
>>> from sympy.simplify.fu import TR1, sec, csc
@@ -989,7 +989,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR2(rv)[source]

+sympy.simplify.fu.TR2(rv)[source]
 
Replace tan and cot with sin/cos and cos/sin

 
Examples

 
>>> from sympy.simplify.fu import TR2
@@ -1007,7 +1007,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR2i(rv, half=False)[source]

+sympy.simplify.fu.TR2i(rv, half=False)[source]
 

 
Converts ratios involving sin and cos as follows::
sin(x)/cos(x) -> tan(x)
 sin(x)/(cos(x) + 1) -> tan(x/2) if half=True

@@ -1037,7 +1037,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR3(rv)[source]

+sympy.simplify.fu.TR3(rv)[source]
 
Induced formula: example sin(-a) = -sin(a)

 
Examples

 
>>> from sympy.simplify.fu import TR3
@@ -1056,7 +1056,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR4(rv)[source]

+sympy.simplify.fu.TR4(rv)[source]
 
Identify values of special angles.

 
A=  0   Pi/6        Pi/4        Pi/3        Pi/2

 
sin(a)  0   1/2         sqrt(2)/2   sqrt(3)/2   1
@@ -1079,7 +1079,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR5(rv, max=4, pow=False)[source]

+sympy.simplify.fu.TR5(rv, max=4, pow=False)[source]
 
Replacement of sin**2 with 1 - cos(x)**2.

 
See _TR56 docstring for advanced use of max and pow.

 
Examples

@@ -1098,7 +1098,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR6(rv, max=4, pow=False)[source]

+sympy.simplify.fu.TR6(rv, max=4, pow=False)[source]
 
Replacement of cos**2 with 1 - sin(x)**2.

 
See _TR56 docstring for advanced use of max and pow.

 
Examples

@@ -1117,7 +1117,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR7(rv)[source]

+sympy.simplify.fu.TR7(rv)[source]
 
Lowering the degree of cos(x)**2.

 
Examples

 
>>> from sympy.simplify.fu import TR7
@@ -1133,7 +1133,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR8(rv, first=True)[source]

+sympy.simplify.fu.TR8(rv, first=True)[source]
 
Converting products of cos and/or sin to a sum or
 difference of cos and or sin terms.

 
Examples

@@ -1151,7 +1151,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR9(rv)[source]

+sympy.simplify.fu.TR9(rv)[source]
 
Sum of cos or sin terms as a product of cos or sin.

 
Examples

 
>>> from sympy.simplify.fu import TR9
@@ -1174,7 +1174,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR10(rv, first=True)[source]

+sympy.simplify.fu.TR10(rv, first=True)[source]
 
Separate sums in cos and sin.

 
Examples

 
>>> from sympy.simplify.fu import TR10
@@ -1192,7 +1192,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR10i(rv)[source]

+sympy.simplify.fu.TR10i(rv)[source]
 
Sum of products to function of sum.

 
Examples

 
>>> from sympy.simplify.fu import TR10i
@@ -1212,7 +1212,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR11(rv, base=None)[source]

+sympy.simplify.fu.TR11(rv, base=None)[source]
 
Function of double angle to product. The base argument can be used
 to indicate what is the un-doubled argument, e.g. if 3*pi/7 is the base
 then cosine and sine functions with argument 6*pi/7 will be replaced.

@@ -1254,7 +1254,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR12(rv, first=True)[source]

+sympy.simplify.fu.TR12(rv, first=True)[source]
 
Separate sums in tan.

 
Examples

 
>>> from sympy.abc import x, y
@@ -1268,7 +1268,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR12i(rv)[source]

+sympy.simplify.fu.TR12i(rv)[source]
 
Combine tan arguments as
 (tan(y) + tan(x))/(tan(x)*tan(y) - 1) -> -tan(x + y).

 
Examples

@@ -1291,7 +1291,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR13(rv)[source]

+sympy.simplify.fu.TR13(rv)[source]
 
Change products of tan or cot.

 
Examples

 
>>> from sympy.simplify.fu import TR13
@@ -1306,7 +1306,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TRmorrie(rv)[source]

+sympy.simplify.fu.TRmorrie(rv)[source]
 
Returns cos(x)*cos(2*x)*…*cos(2**(k-1)*x) -> sin(2**k*x)/(2**k*sin(x))

 
Examples

 
>>> from sympy.simplify.fu import TRmorrie, TR8, TR3
@@ -1367,7 +1367,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR14(rv, first=True)[source]

+sympy.simplify.fu.TR14(rv, first=True)[source]
 
Convert factored powers of sin and cos identities into simpler
 expressions.

 
Examples

@@ -1389,7 +1389,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR15(rv, max=4, pow=False)[source]

+sympy.simplify.fu.TR15(rv, max=4, pow=False)[source]
 
Convert sin(x)**-2 to 1 + cot(x)**2.

 
See _TR56 docstring for advanced use of max and pow.

 
Examples

@@ -1404,7 +1404,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR16(rv, max=4, pow=False)[source]

+sympy.simplify.fu.TR16(rv, max=4, pow=False)[source]
 
Convert cos(x)**-2 to 1 + tan(x)**2.

 
See _TR56 docstring for advanced use of max and pow.

 
Examples

@@ -1419,7 +1419,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR111(rv)[source]

+sympy.simplify.fu.TR111(rv)[source]
 
Convert f(x)**-i to g(x)**i where either i is an integer
 or the base is positive and f, g are: tan, cot; sin, csc; or cos, sec.

 
Examples

@@ -1434,7 +1434,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TR22(rv, max=4, pow=False)[source]

+sympy.simplify.fu.TR22(rv, max=4, pow=False)[source]
 
Convert tan(x)**2 to sec(x)**2 - 1 and cot(x)**2 to csc(x)**2 - 1.

 
See _TR56 docstring for advanced use of max and pow.

 
Examples

@@ -1451,7 +1451,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.TRpower(rv)[source]

+sympy.simplify.fu.TRpower(rv)[source]
 
Convert sin(x)**n and cos(x)**n with positive n to sums.

 
Examples

 
>>> from sympy.simplify.fu import TRpower
@@ -1474,7 +1474,7 @@ 
Rules
 
 

 

-sympy.simplify.fu.fu(rv, measure=<function <lambda>>)[source]

+sympy.simplify.fu.fu(rv, measure=<function <lambda>>)[source]
 
Attempt to simplify expression by using transformation rules given
 in the algorithm by Fu et al.

 
fu() will try to minimize the objective function measure.
diff --git a/dev/modules/simplify/simplify.html b/dev/modules/simplify/simplify.html
index 5ac125128f2..67b53a24feb 100644
--- a/dev/modules/simplify/simplify.html
+++ b/dev/modules/simplify/simplify.html
@@ -814,7 +814,7 @@ 
Documentation Version

 
**kwargs,

 

 
-)[source]
+)[source]
 
Simplifies the given expression.

 
Explanation

 
Simplification is not a well defined term and the exact strategies
@@ -971,7 +971,7 @@ 
Documentation Version

 
force=False,

 

 
-)[source]
+)[source]
 
Separates variables in an expression, if possible.  By
 default, it separates with respect to all symbols in an
 expression and collects constant coefficients that are
@@ -1031,7 +1031,7 @@ 
Documentation Version

 
 

 

-sympy.simplify.simplify.nthroot(expr, n, max_len=4, prec=15)[source]

+sympy.simplify.simplify.nthroot(expr, n, max_len=4, prec=15)[source]
 
Compute a real nth-root of a sum of surds.

 

 
Parameters:

@@ -1055,7 +1055,7 @@ 
Documentation Version

 
 

 

-sympy.simplify.simplify.kroneckersimp(expr)[source]

+sympy.simplify.simplify.kroneckersimp(expr)[source]
 
Simplify expressions with KroneckerDelta.

 
The only simplification currently attempted is to identify multiplicative cancellation:

 
Examples

@@ -1069,7 +1069,7 @@ 
Documentation Version

 
 

 

-sympy.simplify.simplify.besselsimp(expr)[source]

+sympy.simplify.simplify.besselsimp(expr)[source]
 
Simplify bessel-type functions.

 
Explanation

 
This routine tries to simplify bessel-type functions. Currently it only
@@ -1096,7 +1096,7 @@ 
Documentation Version

 
 

 

-sympy.simplify.simplify.hypersimp(f, k)[source]

+sympy.simplify.simplify.hypersimp(f, k)[source]
 
Given combinatorial term f(k) simplify its consecutive term ratio
 i.e. f(k+1)/f(k).  The input term can be composed of functions and
 integer sequences which have equivalent representation in terms
@@ -1124,7 +1124,7 @@ 
Documentation Version

 
 

 

-sympy.simplify.simplify.hypersimilar(f, g, k)[source]

+sympy.simplify.simplify.hypersimilar(f, g, k)[source]
 
Returns True if f and g are hyper-similar.

 
Explanation

 
Similarity in hypergeometric sense means that a quotient of
@@ -1146,7 +1146,7 @@ 
Documentation Version

 
rational_conversion='base10',

 

 
-)[source]
+)[source]
 
Find a simple representation for a number or, if there are free symbols or
 if rational=True, then replace Floats with their Rational equivalents. If
 no change is made and rational is not False then Floats will at least be
@@ -1192,7 +1192,7 @@ 
Documentation Version

 
 

 

-sympy.simplify.simplify.posify(eq)[source]

+sympy.simplify.simplify.posify(eq)[source]
 
Return eq (with generic symbols made positive) and a
 dictionary containing the mapping between the old and new
 symbols.

@@ -1234,7 +1234,7 @@ 
Documentation Version

 
 

 

-sympy.simplify.simplify.logcombine(expr, force=False)[source]

+sympy.simplify.simplify.logcombine(expr, force=False)[source]
 
Takes logarithms and combines them using the following rules:

 
    
 
  • log(x) + log(y) == log(x*y) if both are positive
    • 
@@ -1281,7 +1281,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.simplify.radsimp.radsimp(expr, symbolic=True, max_terms=4)[source]
    
+sympy.simplify.radsimp.radsimp(expr, symbolic=True, max_terms=4)[source]
 
    Rationalize the denominator by removing square roots.
    
 
    Explanation
    
 
    The expression returned from radsimp must be used with caution
@@ -1355,7 +1355,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.simplify.radsimp.rad_rationalize(num, den)[source]
    
+sympy.simplify.radsimp.rad_rationalize(num, den)[source]
 
    Rationalize num/den by removing square roots in the denominator;
 num and den are sum of terms whose squares are positive rationals.
    
 
    Examples
    
@@ -1380,7 +1380,7 @@ 
    Documentation Version
    
 
    distribute_order_term=True,
    
 
    
 
-)[source]
+)[source]
 
    Collect additive terms of an expression.
    
 
    Explanation
    
 
    This function collects additive terms of an expression with respect
@@ -1527,7 +1527,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.simplify.radsimp.rcollect(expr, *vars)[source]
    
+sympy.simplify.radsimp.rcollect(expr, *vars)[source]
 
    Recursively collect sums in an expression.
    
 
    Examples
    
 
    >>> from sympy.simplify import rcollect
@@ -1549,7 +1549,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.simplify.radsimp.collect_sqrt(expr, evaluate=None)[source]
    
+sympy.simplify.radsimp.collect_sqrt(expr, evaluate=None)[source]
 
    Return expr with terms having common square roots collected together.
 If evaluate is False a count indicating the number of sqrt-containing
 terms will be returned and, if non-zero, the terms of the Add will be
@@ -1591,7 +1591,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.simplify.radsimp.collect_const(expr, *vars, Numbers=True)[source]
    
+sympy.simplify.radsimp.collect_const(expr, *vars, Numbers=True)[source]
 
    A non-greedy collection of terms with similar number coefficients in
 an Add expr. If vars is given then only those constants will be
 targeted. Although any Number can also be targeted, if this is not
@@ -1658,7 +1658,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.simplify.radsimp.fraction(expr, exact=False)[source]
    
+sympy.simplify.radsimp.fraction(expr, exact=False)[source]
 
    Returns a pair with expression’s numerator and denominator.
 If the given expression is not a fraction then this function
 will return the tuple (expr, 1).
    
@@ -1721,7 +1721,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.simplify.ratsimp.ratsimp(expr)[source]
    
+sympy.simplify.ratsimp.ratsimp(expr)[source]
 
    Put an expression over a common denominator, cancel and reduce.
    
 
    Examples
    
 
    >>> from sympy import ratsimp
@@ -1745,7 +1745,7 @@ 
    Documentation Version
    
 
    **args,
    
 
    
 
-)[source]
+)[source]
 
    Simplifies a rational expression expr modulo the prime ideal
 generated by G.  G should be a Groebner basis of the
 ideal.
    
@@ -1776,7 +1776,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.simplify.trigsimp.trigsimp(expr, inverse=False, **opts)[source]
    
+sympy.simplify.trigsimp.trigsimp(expr, inverse=False, **opts)[source]
 
    Returns a reduced expression by using known trig identities.
    
 
    
 
    Parameters:
    
@@ -1854,7 +1854,7 @@ 
    Documentation Version
    
 
    measure=<function count_ops>,
    
 
    
 
-)[source]
+)[source]
 
    Reduce expression by combining powers with similar bases and exponents.
    
 
    Explanation
    
 
    If deep is True then powsimp() will also simplify arguments of
@@ -1934,7 +1934,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.simplify.powsimp.powdenest(eq, force=False, polar=False)[source]
    
+sympy.simplify.powsimp.powdenest(eq, force=False, polar=False)[source]
 
    Collect exponents on powers as assumptions allow.
    
 
    Explanation
    
 
    
@@ -2028,7 +2028,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.simplify.combsimp.combsimp(expr)[source]
    
+sympy.simplify.combsimp.combsimp(expr)[source]
 
    Simplify combinatorial expressions.
    
 
    Explanation
    
 
    This function takes as input an expression containing factorials,
@@ -2060,7 +2060,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.simplify.sqrtdenest.sqrtdenest(expr, max_iter=3)[source]
    
+sympy.simplify.sqrtdenest.sqrtdenest(expr, max_iter=3)[source]
 
    Denests sqrts in an expression that contain other square roots
 if possible, otherwise returns the expr unchanged. This is based on the
 algorithms of [1].
    
@@ -2103,7 +2103,7 @@ 
    Documentation Version
    
 
    list=True,
    
 
    
 
-)[source]
+)[source]
 
    Perform common subexpression elimination on an expression.
    
 
    
 
    Parameters:
    
@@ -2199,7 +2199,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.simplify.cse_main.opt_cse(exprs, order='canonical')[source]
    
+sympy.simplify.cse_main.opt_cse(exprs, order='canonical')[source]
 
    Find optimization opportunities in Adds, Muls, Pows and negative
 coefficient Muls.
    
 
    
@@ -2244,7 +2244,7 @@ 
    Documentation Version
    
 
    ignore=(),
    
 
    
 
-)[source]
+)[source]
 
    Perform raw CSE on expression tree, taking opt_subs into account.
    
 
    
 
    Parameters:
    
@@ -2285,7 +2285,7 @@ 
    Documentation Version
    
 
    place=None,
    
 
    
 
-)[source]
+)[source]
 
    Expand hypergeometric functions. If allow_hyper is True, allow partial
 simplification (that is a result different from input,
 but still containing hypergeometric functions).
    
@@ -2310,7 +2310,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.simplify.epathtools.EPath(path)[source]
    
+class sympy.simplify.epathtools.EPath(path)[source]
 
    Manipulate expressions using paths.
    
 
    EPath grammar in EBNF notation:
    
 
    literal   ::= /[A-Za-z_][A-Za-z_0-9]*/
@@ -2328,7 +2328,7 @@ 
    Documentation Version
    
 
    See the docstring of the epath() function.
    
 
    
 
    
-apply(expr, func, args=None, kwargs=None)[source]
    
+apply(expr, func, args=None, kwargs=None)[source]
 
    Modify parts of an expression selected by a path.
    
 
    Examples
    
 
    >>> from sympy.simplify.epathtools import EPath
@@ -2356,7 +2356,7 @@ 
    Documentation Version
    
 
 
    
 
    
-select(expr)[source]
    
+select(expr)[source]
 
    Retrieve parts of an expression selected by a path.
    
 
    Examples
    
 
    >>> from sympy.simplify.epathtools import EPath
@@ -2396,7 +2396,7 @@ 
    Documentation Version
    
 
    kwargs=None,
    
 
    
 
-)[source]
+)[source]
 
    Manipulate parts of an expression selected by a path.
    
 
    
 
    Parameters:
    
diff --git a/dev/modules/solvers/diophantine.html b/dev/modules/solvers/diophantine.html
index 085a001ad3e..f273bcfc107 100644
--- a/dev/modules/solvers/diophantine.html
+++ b/dev/modules/solvers/diophantine.html
@@ -1132,7 +1132,7 @@ 
    User Functionsfrom sympy import *:
    
 
    
 
    
-sympy.solvers.diophantine.diophantine.diophantine(eq, param=t, syms=None, permute=False)[source]
    
+sympy.solvers.diophantine.diophantine.diophantine(eq, param=t, syms=None, permute=False)[source]
 
    Simplify the solution procedure of diophantine equation eq by
 converting it into a product of terms which should equal zero.
    
 
    Explanation
    
@@ -1190,7 +1190,7 @@ 
    User Functionsfrom sympy.solvers.diophantine import *:
    
 
    
 
    
-sympy.solvers.diophantine.diophantine.classify_diop(eq, _dict=True)[source]
    
+sympy.solvers.diophantine.diophantine.classify_diop(eq, _dict=True)[source]
 
    
 
 
@@ -1199,7 +1199,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.diop_solve(eq, param=t)[source]
    
+sympy.solvers.diophantine.diophantine.diop_solve(eq, param=t)[source]
 
    Solves the diophantine equation eq.
    
 
    Explanation
    
 
    Unlike diophantine(), factoring of eq is not attempted. Uses
@@ -1236,7 +1236,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.diop_linear(eq, param=t)[source]
    
+sympy.solvers.diophantine.diophantine.diop_linear(eq, param=t)[source]
 
    Solves linear diophantine equations.
    
 
    A linear diophantine equation is an equation of the form \(a_{1}x_{1} +
 a_{2}x_{2} + .. + a_{n}x_{n} = 0\) where \(a_{1}, a_{2}, ..a_{n}\) are
@@ -1268,7 +1268,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.base_solution_linear(c, a, b, t=None)[source]
    
+sympy.solvers.diophantine.diophantine.base_solution_linear(c, a, b, t=None)[source]
 
    Return the base solution for the linear equation, \(ax + by = c\).
    
 
    Explanation
    
 
    Used by diop_linear() to find the base solution of a linear
@@ -1294,7 +1294,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.diop_quadratic(eq, param=t)[source]
    
+sympy.solvers.diophantine.diophantine.diop_quadratic(eq, param=t)[source]
 
    Solves quadratic diophantine equations.
    
 
    i.e. equations of the form \(Ax^2 + Bxy + Cy^2 + Dx + Ey + F = 0\). Returns a
 set containing the tuples \((x, y)\) which contains the solutions. If there
@@ -1334,7 +1334,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.diop_DN(D, N, t=t)[source]
    
+sympy.solvers.diophantine.diophantine.diop_DN(D, N, t=t)[source]
 
    Solves the equation \(x^2 - Dy^2 = N\).
    
 
    Explanation
    
 
    Mainly concerned with the case \(D > 0, D\) is not a perfect square,
@@ -1389,7 +1389,7 @@ 
    Internal Functionsm: int,
    
 
    
 
-) → set[tuple[int, int]][source]
+) → set[tuple[int, int]][source]
 
    Solves \(ax^2 + by^2 = m\) where \(\gcd(a, b) = 1 = gcd(a, m)\) and \(a, b > 0\).
    
 
    Explanation
    
 
    Uses the algorithm due to Cornacchia. The method only finds primitive
@@ -1428,7 +1428,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.diop_bf_DN(D, N, t=t)[source]
    
+sympy.solvers.diophantine.diophantine.diop_bf_DN(D, N, t=t)[source]
 
    Uses brute force to solve the equation, \(x^2 - Dy^2 = N\).
    
 
    Explanation
    
 
    Mainly concerned with the generalized Pell equation which is the case when
@@ -1467,7 +1467,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.transformation_to_DN(eq)[source]
    
+sympy.solvers.diophantine.diophantine.transformation_to_DN(eq)[source]
 
    This function transforms general quadratic,
 \(ax^2 + bxy + cy^2 + dx + ey + f = 0\)
 to more easy to deal with \(X^2 - DY^2 = N\) form.
    
@@ -1539,7 +1539,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.transformation_to_normal(eq)[source]
    
+sympy.solvers.diophantine.diophantine.transformation_to_normal(eq)[source]
 
    Returns the transformation Matrix that converts a general ternary
 quadratic equation eq (\(ax^2 + by^2 + cz^2 + dxy + eyz + fxz\))
 to a form without cross terms: \(ax^2 + by^2 + cz^2 = 0\). This is
@@ -1549,7 +1549,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.find_DN(eq)[source]
    
+sympy.solvers.diophantine.diophantine.find_DN(eq)[source]
 
    This function returns a tuple, \((D, N)\) of the simplified form,
 \(x^2 - Dy^2 = N\), corresponding to the general quadratic,
 \(ax^2 + bxy + cy^2 + dx + ey + f = 0\).
    
@@ -1585,7 +1585,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.diop_ternary_quadratic(eq, parameterize=False)[source]
    
+sympy.solvers.diophantine.diophantine.diop_ternary_quadratic(eq, parameterize=False)[source]
 
    Solves the general quadratic ternary form,
 \(ax^2 + by^2 + cz^2 + fxy + gyz + hxz = 0\).
    
 
    Returns a tuple \((x, y, z)\) which is a base solution for the above
@@ -1613,7 +1613,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.square_factor(a)[source]
    
+sympy.solvers.diophantine.diophantine.square_factor(a)[source]
 
    Returns an integer \(c\) s.t. \(a = c^2k, \ c,k \in Z\). Here \(k\) is square
 free. \(a\) can be given as an integer or a dictionary of factors.
    
 
    Examples
    
@@ -1636,7 +1636,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.descent(A, B)[source]
    
+sympy.solvers.diophantine.diophantine.descent(A, B)[source]
 
    Returns a non-trivial solution, (x, y, z), to \(x^2 = Ay^2 + Bz^2\)
 using Lagrange’s descent method with lattice-reduction. \(A\) and \(B\)
 are assumed to be valid for such a solution to exist.
    
@@ -1666,7 +1666,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.diop_general_pythagorean(eq, param=m)[source]
    
+sympy.solvers.diophantine.diophantine.diop_general_pythagorean(eq, param=m)[source]
 
    Solves the general pythagorean equation,
 \(a_{1}^2x_{1}^2 + a_{2}^2x_{2}^2 + . . . + a_{n}^2x_{n}^2 - a_{n + 1}^2x_{n + 1}^2 = 0\).
    
 
    Returns a tuple which contains a parametrized solution to the equation,
@@ -1688,7 +1688,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.diop_general_sum_of_squares(eq, limit=1)[source]
    
+sympy.solvers.diophantine.diophantine.diop_general_sum_of_squares(eq, limit=1)[source]
 
    Solves the equation \(x_{1}^2 + x_{2}^2 + . . . + x_{n}^2 - k = 0\).
    
 
    Returns at most limit number of solutions.
    
 
    Usage
    
@@ -1718,7 +1718,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.diop_general_sum_of_even_powers(eq, limit=1)[source]
    
+sympy.solvers.diophantine.diophantine.diop_general_sum_of_even_powers(eq, limit=1)[source]
 
    Solves the equation \(x_{1}^e + x_{2}^e + . . . + x_{n}^e - k = 0\)
 where \(e\) is an even, integer power.
    
 
    Returns at most limit number of solutions.
    
@@ -1741,7 +1741,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.power_representation(n, p, k, zeros=False)[source]
    
+sympy.solvers.diophantine.diophantine.power_representation(n, p, k, zeros=False)[source]
 
    Returns a generator for finding k-tuples of integers,
 \((n_{1}, n_{2}, . . . n_{k})\), such that
 \(n = n_{1}^p + n_{2}^p + . . . n_{k}^p\).
    
@@ -1785,7 +1785,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.partition(n, k=None, zeros=False)[source]
    
+sympy.solvers.diophantine.diophantine.partition(n, k=None, zeros=False)[source]
 
    Returns a generator that can be used to generate partitions of an integer
 \(n\).
    
 
    Explanation
    
@@ -1824,7 +1824,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.sum_of_three_squares(n)[source]
    
+sympy.solvers.diophantine.diophantine.sum_of_three_squares(n)[source]
 
    Returns a 3-tuple \((a, b, c)\) such that \(a^2 + b^2 + c^2 = n\) and
 \(a, b, c \geq 0\).
    
 
    Returns None if \(n = 4^a(8m + 7)\) for some \(a, m \in \mathbb{Z}\). See
@@ -1875,7 +1875,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.sum_of_four_squares(n)[source]
    
+sympy.solvers.diophantine.diophantine.sum_of_four_squares(n)[source]
 
    Returns a 4-tuple \((a, b, c, d)\) such that \(a^2 + b^2 + c^2 + d^2 = n\).
 Here \(a, b, c, d \geq 0\).
    
 
    
@@ -1925,7 +1925,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.sum_of_powers(n, p, k, zeros=False)[source]
    
+sympy.solvers.diophantine.diophantine.sum_of_powers(n, p, k, zeros=False)[source]
 
    Returns a generator for finding k-tuples of integers,
 \((n_{1}, n_{2}, . . . n_{k})\), such that
 \(n = n_{1}^p + n_{2}^p + . . . n_{k}^p\).
    
@@ -1969,7 +1969,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.sum_of_squares(n, k, zeros=False)[source]
    
+sympy.solvers.diophantine.diophantine.sum_of_squares(n, k, zeros=False)[source]
 
    Return a generator that yields the k-tuples of nonnegative
 values, the squares of which sum to n. If zeros is False (default)
 then the solution will not contain zeros. The nonnegative
@@ -2012,7 +2012,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.merge_solution(var, var_t, solution)[source]
    
+sympy.solvers.diophantine.diophantine.merge_solution(var, var_t, solution)[source]
 
    This is used to construct the full solution from the solutions of sub
 equations.
    
 
    Explanation
    
@@ -2026,13 +2026,13 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.divisible(a, b)[source]
    
+sympy.solvers.diophantine.diophantine.divisible(a, b)[source]
 
    Returns \(True\) if a is divisible by b and \(False\) otherwise.
    
 
    
 
 
    
 
    
-sympy.solvers.diophantine.diophantine.PQa(P_0, Q_0, D)[source]
    
+sympy.solvers.diophantine.diophantine.PQa(P_0, Q_0, D)[source]
 
    Returns useful information needed to solve the Pell equation.
    
 
    Explanation
    
 
    There are six sequences of integers defined related to the continued
@@ -2067,7 +2067,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.equivalent(u, v, r, s, D, N)[source]
    
+sympy.solvers.diophantine.diophantine.equivalent(u, v, r, s, D, N)[source]
 
    Returns True if two solutions \((u, v)\) and \((r, s)\) of \(x^2 - Dy^2 = N\)
 belongs to the same equivalence class and False otherwise.
    
 
    Explanation
    
@@ -2100,7 +2100,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.parametrize_ternary_quadratic(eq)[source]
    
+sympy.solvers.diophantine.diophantine.parametrize_ternary_quadratic(eq)[source]
 
    Returns the parametrized general solution for the ternary quadratic
 equation eq which has the form
 \(ax^2 + by^2 + cz^2 + fxy + gyz + hxz = 0\).
    
@@ -2161,7 +2161,7 @@ 
    Internal Functionsparameterize=False,
    
 
    
 
-)[source]
+)[source]
 
    Solves the quadratic ternary diophantine equation,
 \(ax^2 + by^2 + cz^2 = 0\).
    
 
    Explanation
    
@@ -2187,7 +2187,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.ldescent(A, B)[source]
    
+sympy.solvers.diophantine.diophantine.ldescent(A, B)[source]
 
    Return a non-trivial solution to \(w^2 = Ax^2 + By^2\) using
 Lagrange’s method; return None if there is no such solution.
    
 
    
@@ -2243,7 +2243,7 @@ 
    Internal Functionsb: int,
    
 
    
 
-) → tuple[int, int][source]
+) → tuple[int, int][source]
 
    Returns a reduced solution \((x, z)\) to the congruence
 \(X^2 - aZ^2 \equiv 0 \pmod{b}\) so that \(x^2 + |a|z^2\) is as small as possible.
 Here w is a solution of the congruence \(x^2 \equiv a \pmod{b}\).
    
@@ -2318,7 +2318,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.holzer(x, y, z, a, b, c)[source]
    
+sympy.solvers.diophantine.diophantine.holzer(x, y, z, a, b, c)[source]
 
    Simplify the solution \((x, y, z)\) of the equation
 \(ax^2 + by^2 = cz^2\) with \(a, b, c > 0\) and \(z^2 \geq \mid ab \mid\) to
 a new reduced solution \((x', y', z')\) such that \(z'^2 \leq \mid ab \mid\).
    
@@ -2344,7 +2344,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.prime_as_sum_of_two_squares(p)[source]
    
+sympy.solvers.diophantine.diophantine.prime_as_sum_of_two_squares(p)[source]
 
    Represent a prime \(p\) as a unique sum of two squares; this can
 only be done if the prime is congruent to 1 mod 4.
    
 
    
@@ -2390,7 +2390,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.sqf_normal(a, b, c, steps=False)[source]
    
+sympy.solvers.diophantine.diophantine.sqf_normal(a, b, c, steps=False)[source]
 
    Return \(a', b', c'\), the coefficients of the square-free normal
 form of \(ax^2 + by^2 + cz^2 = 0\), where \(a', b', c'\) are pairwise
 prime.  If \(steps\) is True then also return three tuples:
@@ -2424,7 +2424,7 @@ 
    Internal Functions
 
    
-sympy.solvers.diophantine.diophantine.reconstruct(A, B, z)[source]
    
+sympy.solvers.diophantine.diophantine.reconstruct(A, B, z)[source]
 
    Reconstruct the \(z\) value of an equivalent solution of \(ax^2 + by^2 + cz^2\)
 from the \(z\) value of a solution of the square-free normal form of the
 equation, \(a'*x^2 + b'*y^2 + c'*z^2\), where \(a'\), \(b'\) and \(c'\) are square
@@ -2437,7 +2437,7 @@ 
    Internal Classes
 
    
-class sympy.solvers.diophantine.diophantine.DiophantineSolutionSet(symbols_seq, parameters)[source]
    
+class sympy.solvers.diophantine.diophantine.DiophantineSolutionSet(symbols_seq, parameters)[source]
 
    Container for a set of solutions to a particular diophantine equation.
    
 
    The base representation is a set of tuples representing each of the solutions.
    
 
    
@@ -2508,7 +2508,7 @@ 
    Internal Classesfree_symbols=None,
    
 
    
 
-)[source]
+)[source]
 
    Internal representation of a particular diophantine equation type.
    
 
    
 
    Parameters:
    
@@ -2543,7 +2543,7 @@ 
    Internal Classes
 
    
-matches()[source]
    
+matches()[source]
 
    Determine whether the given equation can be matched to the particular equation type.
    
 
    
 
@@ -2551,7 +2551,7 @@ 
    Internal Classes
 
    
-class sympy.solvers.diophantine.diophantine.Univariate(equation, free_symbols=None)[source]
    
+class sympy.solvers.diophantine.diophantine.Univariate(equation, free_symbols=None)[source]
 
    Representation of a univariate diophantine equation.
    
 
    A univariate diophantine equation is an equation of the form
 \(a_{0} + a_{1}x + a_{2}x^2 + .. + a_{n}x^n = 0\) where \(a_{1}, a_{2}, ..a_{n}\) are
@@ -2567,7 +2567,7 @@ 
    Internal Classes
 
    
-class sympy.solvers.diophantine.diophantine.Linear(equation, free_symbols=None)[source]
    
+class sympy.solvers.diophantine.diophantine.Linear(equation, free_symbols=None)[source]
 
    Representation of a linear diophantine equation.
    
 
    A linear diophantine equation is an equation of the form \(a_{1}x_{1} +
 a_{2}x_{2} + .. + a_{n}x_{n} = 0\) where \(a_{1}, a_{2}, ..a_{n}\) are
@@ -2591,7 +2591,7 @@ 
    Internal Classes
 
    
-class sympy.solvers.diophantine.diophantine.BinaryQuadratic(equation, free_symbols=None)[source]
    
+class sympy.solvers.diophantine.diophantine.BinaryQuadratic(equation, free_symbols=None)[source]
 
    Representation of a binary quadratic diophantine equation.
    
 
    A binary quadratic diophantine equation is an equation of the
 form \(Ax^2 + Bxy + Cy^2 + Dx + Ey + F = 0\), where \(A, B, C, D, E,
@@ -2633,7 +2633,7 @@ 
    Internal Classesfree_symbols=None,
    
 
    
 
-)[source]
+)[source]
 
    Representation of an inhomogeneous ternary quadratic.
    
 
    No solver is currently implemented for this equation type.
    
 
    
@@ -2647,7 +2647,7 @@ 
    Internal Classesfree_symbols=None,
    
 
    
 
-)[source]
+)[source]
 
    Representation of a homogeneous ternary quadratic normal diophantine equation.
    
 
    Examples
    
 
    >>> from sympy.abc import x, y, z
@@ -2667,7 +2667,7 @@ 
    Internal Classesfree_symbols=None,
    
 
    
 
-)[source]
+)[source]
 
    Representation of a homogeneous ternary quadratic diophantine equation.
    
 
    Examples
    
 
    >>> from sympy.abc import x, y, z
@@ -2689,7 +2689,7 @@ 
    Internal Classesfree_symbols=None,
    
 
    
 
-)[source]
+)[source]
 
    Representation of an inhomogeneous general quadratic.
    
 
    No solver is currently implemented for this equation type.
    
 
    
@@ -2703,14 +2703,14 @@ 
    Internal Classesfree_symbols=None,
    
 
    
 
-)[source]
+)[source]
 
    Representation of a homogeneous general quadratic.
    
 
    No solver is currently implemented for this equation type.
    
 
    
 
 
    
 
    
-class sympy.solvers.diophantine.diophantine.GeneralSumOfSquares(equation, free_symbols=None)[source]
    
+class sympy.solvers.diophantine.diophantine.GeneralSumOfSquares(equation, free_symbols=None)[source]
 
    Representation of the diophantine equation
    
 
    \(x_{1}^2 + x_{2}^2 + . . . + x_{n}^2 - k = 0\).
    
 
    Details
    
@@ -2742,7 +2742,7 @@ 
    Internal Classes
 
    
-class sympy.solvers.diophantine.diophantine.GeneralPythagorean(equation, free_symbols=None)[source]
    
+class sympy.solvers.diophantine.diophantine.GeneralPythagorean(equation, free_symbols=None)[source]
 
    Representation of the general pythagorean equation,
 \(a_{1}^2x_{1}^2 + a_{2}^2x_{2}^2 + . . . + a_{n}^2x_{n}^2 - a_{n + 1}^2x_{n + 1}^2 = 0\).
    
 
    Examples
    
@@ -2758,7 +2758,7 @@ 
    Internal Classes
 
    
-class sympy.solvers.diophantine.diophantine.CubicThue(equation, free_symbols=None)[source]
    
+class sympy.solvers.diophantine.diophantine.CubicThue(equation, free_symbols=None)[source]
 
    Representation of a cubic Thue diophantine equation.
    
 
    A cubic Thue diophantine equation is a polynomial of the form
 \(f(x, y) = r\) of degree 3, where \(x\) and \(y\) are integers
@@ -2783,7 +2783,7 @@ 
    Internal Classesfree_symbols=None,
    
 
    
 
-)[source]
+)[source]
 
    Representation of the diophantine equation
    
 
    \(x_{1}^e + x_{2}^e + . . . + x_{n}^e - k = 0\)
    
 
    where \(e\) is an even, integer power.
    
diff --git a/dev/modules/solvers/inequalities.html b/dev/modules/solvers/inequalities.html
index d1c060c2bdd..c11f1e1f4fc 100644
--- a/dev/modules/solvers/inequalities.html
+++ b/dev/modules/solvers/inequalities.html
@@ -816,7 +816,7 @@ 
    Documentation Version
    
 
    
 
    
 
    
-sympy.solvers.inequalities.solve_rational_inequalities(eqs)[source]
    
+sympy.solvers.inequalities.solve_rational_inequalities(eqs)[source]
 
    Solve a system of rational inequalities with rational coefficients.
    
 
    Examples
    
 
    >>> from sympy.abc import x
@@ -843,7 +843,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.solvers.inequalities.solve_poly_inequality(poly, rel)[source]
    
+sympy.solvers.inequalities.solve_poly_inequality(poly, rel)[source]
 
    Solve a polynomial inequality with rational coefficients.
    
 
    Examples
    
 
    >>> from sympy import solve_poly_inequality, Poly
@@ -870,7 +870,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.solvers.inequalities.solve_poly_inequalities(polys)[source]
    
+sympy.solvers.inequalities.solve_poly_inequalities(polys)[source]
 
    Solve polynomial inequalities with rational coefficients.
    
 
    Examples
    
 
    >>> from sympy import Poly
@@ -894,7 +894,7 @@ 
    Documentation Version
    
 
    relational=True,
    
 
    
 
-)[source]
+)[source]
 
    Reduce a system of rational inequalities with rational coefficients.
    
 
    Examples
    
 
    >>> from sympy import Symbol
@@ -928,7 +928,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.solvers.inequalities.reduce_abs_inequality(expr, rel, gen)[source]
    
+sympy.solvers.inequalities.reduce_abs_inequality(expr, rel, gen)[source]
 
    Reduce an inequality with nested absolute values.
    
 
    Examples
    
 
    >>> from sympy import reduce_abs_inequality, Abs, Symbol
@@ -951,7 +951,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.solvers.inequalities.reduce_abs_inequalities(exprs, gen)[source]
    
+sympy.solvers.inequalities.reduce_abs_inequalities(exprs, gen)[source]
 
    Reduce a system of inequalities with nested absolute values.
    
 
    Examples
    
 
    >>> from sympy import reduce_abs_inequalities, Abs, Symbol
@@ -975,7 +975,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.solvers.inequalities.reduce_inequalities(inequalities, symbols=[])[source]
    
+sympy.solvers.inequalities.reduce_inequalities(inequalities, symbols=[])[source]
 
    Reduce a system of inequalities with rational coefficients.
    
 
    Examples
    
 
    >>> from sympy.abc import x, y
@@ -1004,7 +1004,7 @@ 
    Documentation Version
    
 
    continuous=False,
    
 
    
 
-)[source]
+)[source]
 
    Solves a real univariate inequality.
    
 
    
 
    Parameters:
    
diff --git a/dev/modules/solvers/ode.html b/dev/modules/solvers/ode.html
index 48a97340621..057e59d960f 100644
--- a/dev/modules/solvers/ode.html
+++ b/dev/modules/solvers/ode.html
@@ -827,7 +827,7 @@ 
    Documentation Version
    
 
    **kwargs,
    
 
    
 
-)[source]
+)[source]
 
    Solves any (supported) kind of ordinary differential equation and
 system of ordinary differential equations.
    
 
    For Single Ordinary Differential Equation
    
@@ -1025,7 +1025,7 @@ 
    Documentation Version
    
 
    simplify=True,
    
 
    
 
-)[source]
+)[source]
 
    Solves any(supported) system of Ordinary Differential Equations
    
 
    
 
    Parameters:
    
@@ -1139,7 +1139,7 @@ 
    Documentation Version
    
 
    **kwargs,
    
 
    
 
-)[source]
+)[source]
 
    Returns a tuple of possible dsolve()
 classifications for an ODE.
    
 
    The tuple is ordered so that first item is the classification that
@@ -1267,7 +1267,7 @@ 
    Documentation Version
    
 
    solve_for_func=True,
    
 
    
 
-)[source]
+)[source]
 
    Substitutes sol into ode and checks that the result is 0.
    
 
    This works when func is one function, like \(f(x)\) or a list of
 functions like \([f(x), g(x)]\) when \(ode\) is a system of ODEs.  sol can
@@ -1328,7 +1328,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.solvers.ode.homogeneous_order(eq, *symbols)[source]
    
+sympy.solvers.ode.homogeneous_order(eq, *symbols)[source]
 
    Returns the order \(n\) if \(g\) is homogeneous and None if it is not
 homogeneous.
    
 
    Determines if a function is homogeneous and if so of what order.  A
@@ -1376,7 +1376,7 @@ 
    Documentation Version
    
 
    match=None,
    
 
    
 
-)[source]
+)[source]
 
    The infinitesimal functions of an ordinary differential equation, \(\xi(x,y)\)
 and \(\eta(x,y)\), are the infinitesimals of the Lie group of point transformations
 for which the differential equation is invariant. So, the ODE \(y'=f(x,y)\)
@@ -1445,7 +1445,7 @@ 
    Documentation Version
    
 
    order=None,
    
 
    
 
-)[source]
+)[source]
 
    This function is used to check if the given infinitesimals are the
 actual infinitesimals of the given first order differential equation.
 This method is specific to the Lie Group Solver of ODEs.
    
@@ -1469,7 +1469,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.solvers.ode.constantsimp(expr, constants)[source]
    
+sympy.solvers.ode.constantsimp(expr, constants)[source]
 
    Simplifies an expression with arbitrary constants in it.
    
 
    This function is written specifically to work with
 dsolve(), and is not intended for general use.
    
@@ -1543,7 +1543,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.solvers.ode.ode.odesimp(ode, eq, func, hint)[source]
    
+sympy.solvers.ode.ode.odesimp(ode, eq, func, hint)[source]
 
    Simplifies solutions of ODEs, including trying to solve for func and
 running constantsimp().
    
 
    It may use knowledge of the type of solution that the hint returns to
@@ -1607,7 +1607,7 @@ 
    Documentation Version
    
 
    newconstants=None,
    
 
    
 
-)[source]
+)[source]
 
    Renumber arbitrary constants in expr to use the symbol names as given
 in newconstants. In the process, this reorders expression terms in a
 standard way.
    
@@ -1651,7 +1651,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.solvers.ode.ode.ode_sol_simplicity(sol, func, trysolving=True)[source]
    
+sympy.solvers.ode.ode.ode_sol_simplicity(sol, func, trysolving=True)[source]
 
    Returns an extended integer representing how simple a solution to an ODE
 is.
    
 
    The following things are considered, in order from most simple to least:
    
@@ -1732,7 +1732,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.Factorable(ode_problem)[source]
    
+class sympy.solvers.ode.single.Factorable(ode_problem)[source]
 
    Solves equations having a solvable factor.
    
 
    This function is used to solve the equation having factors. Factors may be of type algebraic or ode. It
 will try to solve each factor independently. Factors will be solved by calling dsolve. We will return the
@@ -1751,7 +1751,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.FirstExact(ode_problem)[source]
    
+class sympy.solvers.ode.single.FirstExact(ode_problem)[source]
 
    Solves 1st order exact ordinary differential equations.
    
 
    A 1st order differential equation is called exact if it is the total
 differential of a function. That is, the differential equation
    
@@ -1804,7 +1804,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.HomogeneousCoeffBest(ode_problem)[source]
    
+class sympy.solvers.ode.single.HomogeneousCoeffBest(ode_problem)[source]
 
    Returns the best solution to an ODE from the two hints
 1st_homogeneous_coeff_subs_dep_div_indep and
 1st_homogeneous_coeff_subs_indep_div_dep.
    
@@ -1841,7 +1841,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.HomogeneousCoeffSubsDepDivIndep(ode_problem)[source]
    
+class sympy.solvers.ode.single.HomogeneousCoeffSubsDepDivIndep(ode_problem)[source]
 
    Solves a 1st order differential equation with homogeneous coefficients
 using the substitution \(u_1 = \frac{\text{<dependent
 variable>}}{\text{<independent variable>}}\).
    
@@ -1914,7 +1914,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.HomogeneousCoeffSubsIndepDivDep(ode_problem)[source]
    
+class sympy.solvers.ode.single.HomogeneousCoeffSubsIndepDivDep(ode_problem)[source]
 
    Solves a 1st order differential equation with homogeneous coefficients
 using the substitution \(u_2 = \frac{\text{<independent
 variable>}}{\text{<dependent variable>}}\).
    
@@ -1990,7 +1990,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.FirstLinear(ode_problem)[source]
    
+class sympy.solvers.ode.single.FirstLinear(ode_problem)[source]
 
    Solves 1st order linear differential equations.
    
 
    These are differential equations of the form
    
 
    
@@ -2039,7 +2039,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.RationalRiccati(ode_problem)[source]
    
+class sympy.solvers.ode.single.RationalRiccati(ode_problem)[source]
 
    Gives general solutions to the first order Riccati differential
 equations that have atleast one rational particular solution.
    
 
    
@@ -2072,7 +2072,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.SecondLinearAiry(ode_problem)[source]
    
+class sympy.solvers.ode.single.SecondLinearAiry(ode_problem)[source]
 
    Gives solution of the Airy differential equation
    
 
    
 
    
@@ -2092,7 +2092,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.SecondLinearBessel(ode_problem)[source]
    
+class sympy.solvers.ode.single.SecondLinearBessel(ode_problem)[source]
 
    Gives solution of the Bessel differential equation
    
 
    
 
    
@@ -2121,7 +2121,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.Bernoulli(ode_problem)[source]
    
+class sympy.solvers.ode.single.Bernoulli(ode_problem)[source]
 
    Solves Bernoulli differential equations.
    
 
    These are equations of the form
    
 
    
@@ -2193,7 +2193,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.Liouville(ode_problem)[source]
    
+class sympy.solvers.ode.single.Liouville(ode_problem)[source]
 
    Solves 2nd order Liouville differential equations.
    
 
    The general form of a Liouville ODE is
    
 
    
@@ -2249,7 +2249,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.RiccatiSpecial(ode_problem)[source]
    
+class sympy.solvers.ode.single.RiccatiSpecial(ode_problem)[source]
 
    The general Riccati equation has the form
    
 
    
 
    
@@ -2291,7 +2291,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.NthLinearConstantCoeffHomogeneous(ode_problem)[source]
    
+class sympy.solvers.ode.single.NthLinearConstantCoeffHomogeneous(ode_problem)[source]
 
    Solves an \(n\)th order linear homogeneous differential equation with
 constant coefficients.
    
 
    This is an equation of the form
    
@@ -2358,7 +2358,7 @@ 
    Documentation Version
    
 
    ode_problem,
    
 
    
 
-)[source]
+)[source]
 
    Solves an \(n\)th order linear differential equation with constant
 coefficients using the method of undetermined coefficients.
    
 
    This method works on differential equations of the form
    
@@ -2417,7 +2417,7 @@ 
    Documentation Version
    
 
    ode_problem,
    
 
    
 
-)[source]
+)[source]
 
    Solves an \(n\)th order linear differential equation with constant
 coefficients using the method of variation of parameters.
    
 
    This method works on any differential equations of the form
    
@@ -2484,7 +2484,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.NthLinearEulerEqHomogeneous(ode_problem)[source]
    
+class sympy.solvers.ode.single.NthLinearEulerEqHomogeneous(ode_problem)[source]
 
    Solves an \(n\)th order linear homogeneous variable-coefficient
 Cauchy-Euler equidimensional ordinary differential equation.
    
 
    This is an equation with form \(0 = a_0 f(x) + a_1 x f'(x) + a_2 x^2 f''(x)
@@ -2553,7 +2553,7 @@ 
    Documentation Version
    
 
    ode_problem,
    
 
    
 
-)[source]
+)[source]
 
    Solves an \(n\)th order linear non homogeneous Cauchy-Euler equidimensional
 ordinary differential equation using variation of parameters.
    
 
    This is an equation with form \(g(x) = a_0 f(x) + a_1 x f'(x) + a_2 x^2 f''(x)
@@ -2611,7 +2611,7 @@ 
    Documentation Version
    
 
    ode_problem,
    
 
    
 
-)[source]
+)[source]
 
    Solves an \(n\)th order linear non homogeneous Cauchy-Euler equidimensional
 ordinary differential equation using undetermined coefficients.
    
 
    This is an equation with form \(g(x) = a_0 f(x) + a_1 x f'(x) + a_2 x^2 f''(x)
@@ -2653,7 +2653,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.NthAlgebraic(ode_problem)[source]
    
+class sympy.solvers.ode.single.NthAlgebraic(ode_problem)[source]
 
    Solves an \(n\)th order ordinary differential equation using algebra and
 integrals.
    
 
    There is no general form for the kind of equation that this can solve. The
@@ -2674,7 +2674,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.NthOrderReducible(ode_problem)[source]
    
+class sympy.solvers.ode.single.NthOrderReducible(ode_problem)[source]
 
    Solves ODEs that only involve derivatives of the dependent variable using
 a substitution of the form \(f^n(x) = g(x)\).
    
 
    For example any second order ODE of the form \(f''(x) = h(f'(x), x)\) can be
@@ -2696,7 +2696,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.Separable(ode_problem)[source]
    
+class sympy.solvers.ode.single.Separable(ode_problem)[source]
 
    Solves separable 1st order differential equations.
    
 
    This is any differential equation that can be written as \(P(y)
 \tfrac{dy}{dx} = Q(x)\).  The solution can then just be found by
@@ -2749,7 +2749,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.AlmostLinear(ode_problem)[source]
    
+class sympy.solvers.ode.single.AlmostLinear(ode_problem)[source]
 
    Solves an almost-linear differential equation.
    
 
    The general form of an almost linear differential equation is
    
 
    
@@ -2795,7 +2795,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.LinearCoefficients(ode_problem)[source]
    
+class sympy.solvers.ode.single.LinearCoefficients(ode_problem)[source]
 
    Solves a differential equation with linear coefficients.
    
 
    The general form of a differential equation with linear coefficients is
    
 
    
@@ -2840,7 +2840,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.SeparableReduced(ode_problem)[source]
    
+class sympy.solvers.ode.single.SeparableReduced(ode_problem)[source]
 
    Solves a differential equation that can be reduced to the separable form.
    
 
    The general form of this equation is
    
 
    
@@ -2901,7 +2901,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.LieGroup(ode_problem)[source]
    
+class sympy.solvers.ode.single.LieGroup(ode_problem)[source]
 
    This hint implements the Lie group method of solving first order differential
 equations. The aim is to convert the given differential equation from the
 given coordinate system into another coordinate system where it becomes
@@ -2951,7 +2951,7 @@ 
    Documentation Version
    
 
 
    
 
    
-class sympy.solvers.ode.single.SecondHypergeometric(ode_problem)[source]
    
+class sympy.solvers.ode.single.SecondHypergeometric(ode_problem)[source]
 
    Solves 2nd order linear differential equations.
    
 
    It computes special function solutions which can be expressed using the
 2F1, 1F1 or 0F1 hypergeometric functions.
    
@@ -3000,7 +3000,7 @@ 
    Documentation Version
    
 
 
    
 
    
-sympy.solvers.ode.ode.ode_1st_power_series(eq, func, order, match)[source]
    
+sympy.solvers.ode.ode.ode_1st_power_series(eq, func, order, match)[source]
 
    The power series solution is a method which gives the Taylor series expansion
 to the solution of a differential equation.
    
 
    For a first order differential equation \(\frac{dy}{dx} = h(x, y)\), a power
@@ -3047,7 +3047,7 @@ 
    Documentation Version
    
 
    match,
    
 
    
 
-)[source]
+)[source]
 
    Gives a power series solution to a second order homogeneous differential
 equation with polynomial coefficients at an ordinary point. A homogeneous
 differential equation is of the form
    
@@ -3091,7 +3091,7 @@ 
    Documentation Version
    
 
    match,
    
 
    
 
-)[source]
+)[source]
 
    Gives a power series solution to a second order homogeneous differential
 equation with polynomial coefficients at a regular point. A second order
 homogeneous differential equation is of the form
    
@@ -3150,7 +3150,7 @@ 
    Lie heuristics
 
    
-sympy.solvers.ode.lie_group.lie_heuristic_abaco1_simple(match, comp=False)[source]
    
+sympy.solvers.ode.lie_group.lie_heuristic_abaco1_simple(match, comp=False)[source]
 
    The first heuristic uses the following four sets of
 assumptions on \(\xi\) and \(\eta\)
    
 
    
@@ -3190,7 +3190,7 @@ 
    Lie heuristics
 
    
-sympy.solvers.ode.lie_group.lie_heuristic_abaco1_product(match, comp=False)[source]
    
+sympy.solvers.ode.lie_group.lie_heuristic_abaco1_product(match, comp=False)[source]
 
    The second heuristic uses the following two assumptions on \(\xi\) and \(\eta\)
    
 
    
 
    
@@ -3223,7 +3223,7 @@ 
    Lie heuristics
 
    
-sympy.solvers.ode.lie_group.lie_heuristic_bivariate(match, comp=False)[source]
    
+sympy.solvers.ode.lie_group.lie_heuristic_bivariate(match, comp=False)[source]
 
    The third heuristic assumes the infinitesimals \(\xi\) and \(\eta\)
 to be bi-variate polynomials in \(x\) and \(y\). The assumption made here
 for the logic below is that \(h\) is a rational function in \(x\) and \(y\)
@@ -3242,7 +3242,7 @@ 
    Lie heuristics
 
    
-sympy.solvers.ode.lie_group.lie_heuristic_chi(match, comp=False)[source]
    
+sympy.solvers.ode.lie_group.lie_heuristic_chi(match, comp=False)[source]
 
    The aim of the fourth heuristic is to find the function \(\chi(x, y)\)
 that satisfies the PDE \(\frac{d\chi}{dx} + h\frac{d\chi}{dx}
 - \frac{\partial h}{\partial y}\chi = 0\).
    
@@ -3263,7 +3263,7 @@ 
    Lie heuristics
 
    
-sympy.solvers.ode.lie_group.lie_heuristic_abaco2_similar(match, comp=False)[source]
    
+sympy.solvers.ode.lie_group.lie_heuristic_abaco2_similar(match, comp=False)[source]
 
    This heuristic uses the following two assumptions on \(\xi\) and \(\eta\)
    
 
    
 
    
@@ -3301,7 +3301,7 @@ 
    Lie heuristics
 
    
-sympy.solvers.ode.lie_group.lie_heuristic_function_sum(match, comp=False)[source]
    
+sympy.solvers.ode.lie_group.lie_heuristic_function_sum(match, comp=False)[source]
 
    This heuristic uses the following two assumptions on \(\xi\) and \(\eta\)
    
 
    
 
    
@@ -3348,7 +3348,7 @@ 
    Lie heuristicscomp=False,
    
 
    
 
-)[source]
+)[source]
 
    This heuristic assumes the presence of unknown functions or known functions
 with non-integer powers.
    
 
      
@@ -3384,7 +3384,7 @@ 
      Lie heuristicscomp=False,
    
 
    
 
-)[source]
+)[source]
 
    This heuristic finds if infinitesimals of the form \(\eta = f(x)\), \(\xi = g(y)\)
 without making any assumptions on \(h\).
    
 
    The complete sequence of steps is given in the paper mentioned below.
    
@@ -3397,7 +3397,7 @@ 
    Lie heuristics
 
    
-sympy.solvers.ode.lie_group.lie_heuristic_linear(match, comp=False)[source]
    
+sympy.solvers.ode.lie_group.lie_heuristic_linear(match, comp=False)[source]
 
    This heuristic assumes
    
 
      
 
    1. \(\xi = ax + by + c\) and
      2. 
@@ -3428,7 +3428,7 @@ 
      Rational Riccati Solver
 
      
 
      
-sympy.solvers.ode.riccati.riccati_normal(w, x, b1, b2)[source]
      
+sympy.solvers.ode.riccati.riccati_normal(w, x, b1, b2)[source]
 
      Given a solution \(w(x)\) to the equation
      
 
      
 
      
@@ -3451,28 +3451,28 @@ 
      Rational Riccati Solver
 
      
-sympy.solvers.ode.riccati.riccati_inverse_normal(y, x, b1, b2, bp=None)[source]
      
+sympy.solvers.ode.riccati.riccati_inverse_normal(y, x, b1, b2, bp=None)[source]
 
      Inverse transforming the solution to the normal
 Riccati ODE to get the solution to the Riccati ODE.
      
 
      
 
 
      
 
      
-sympy.solvers.ode.riccati.riccati_reduced(eq, f, x)[source]
      
+sympy.solvers.ode.riccati.riccati_reduced(eq, f, x)[source]
 
      Convert a Riccati ODE into its corresponding
 normal Riccati ODE.
      
 
      
 
 
      
 
      
-sympy.solvers.ode.riccati.construct_c(num, den, x, poles, muls)[source]
      
+sympy.solvers.ode.riccati.construct_c(num, den, x, poles, muls)[source]
 
      Helper function to calculate the coefficients
 in the c-vector for each pole.
      
 
      
 
 
      
 
      
-sympy.solvers.ode.riccati.construct_d(num, den, x, val_inf)[source]
      
+sympy.solvers.ode.riccati.construct_d(num, den, x, val_inf)[source]
 
      Helper function to calculate the coefficients
 in the d-vector based on the valuation of the
 function at oo.
      
@@ -3480,7 +3480,7 @@ 
      Rational Riccati Solver
 
      
-sympy.solvers.ode.riccati.rational_laurent_series(num, den, x, r, m, n)[source]
      
+sympy.solvers.ode.riccati.rational_laurent_series(num, den, x, r, m, n)[source]
 
      The function computes the Laurent series coefficients
 of a rational function.
      
 
      
@@ -3525,7 +3525,7 @@ 
      Rational Riccati Solver
 
      
-sympy.solvers.ode.riccati.compute_m_ybar(x, poles, choice, N)[source]
      
+sympy.solvers.ode.riccati.compute_m_ybar(x, poles, choice, N)[source]
 
      Helper function to calculate -
      
 
      1. m - The degree bound for the polynomial
 solution that must be found for the auxiliary
@@ -3536,7 +3536,7 @@ 
      Rational Riccati Solver
 
      
-sympy.solvers.ode.riccati.solve_aux_eq(numa, dena, numy, deny, x, m)[source]
      
+sympy.solvers.ode.riccati.solve_aux_eq(numa, dena, numy, deny, x, m)[source]
 
      Helper function to find a polynomial solution
 of degree m for the auxiliary differential
 equation.
      
@@ -3544,14 +3544,14 @@ 
      Rational Riccati Solver
 
      
-sympy.solvers.ode.riccati.remove_redundant_sols(sol1, sol2, x)[source]
      
+sympy.solvers.ode.riccati.remove_redundant_sols(sol1, sol2, x)[source]
 
      Helper function to remove redundant
 solutions to the differential equation.
      
 
      
 
 
      
 
      
-sympy.solvers.ode.riccati.get_gen_sol_from_part_sol(part_sols, a, x)[source]
      
+sympy.solvers.ode.riccati.get_gen_sol_from_part_sol(part_sols, a, x)[source]
 
      ”
 Helper function which computes the general
 solution for a Riccati ODE from its particular
@@ -3567,7 +3567,7 @@ 
      Rational Riccati Solver
 
      
-sympy.solvers.ode.riccati.solve_riccati(fx, x, b0, b1, b2, gensol=False)[source]
      
+sympy.solvers.ode.riccati.solve_riccati(fx, x, b0, b1, b2, gensol=False)[source]
 
      The main function that gives particular/general
 solutions to Riccati ODEs that have atleast 1
 rational particular solution.
      
@@ -3580,7 +3580,7 @@ 
      System of ODEsdsolve() for system of differential equations.
      
 
      
 
      
-sympy.solvers.ode.ode._linear_2eq_order1_type6(x, y, t, r, eq)[source]
      
+sympy.solvers.ode.ode._linear_2eq_order1_type6(x, y, t, r, eq)[source]
 
      The equations of this type of ode are .
      
 
      
 
      
@@ -3607,7 +3607,7 @@ 
      System of ODEs
 
      
-sympy.solvers.ode.ode._linear_2eq_order1_type7(x, y, t, r, eq)[source]
      
+sympy.solvers.ode.ode._linear_2eq_order1_type7(x, y, t, r, eq)[source]
 
      The equations of this type of ode are .
      
 
      
 
      
@@ -3650,7 +3650,7 @@ 
      System of ODEs
 
      
-sympy.solvers.ode.systems.linear_ode_to_matrix(eqs, funcs, t, order)[source]
      
+sympy.solvers.ode.systems.linear_ode_to_matrix(eqs, funcs, t, order)[source]
 
      Convert a linear system of ODEs to matrix form
      
 
      
 
      Parameters:
      
@@ -3779,7 +3779,7 @@ 
      System of ODEs
 
      
-sympy.solvers.ode.systems.canonical_odes(eqs, funcs, t)[source]
      
+sympy.solvers.ode.systems.canonical_odes(eqs, funcs, t)[source]
 
      Function that solves for highest order derivatives in a system
      
 
      
 
      Parameters:
      
@@ -3840,7 +3840,7 @@ 
      System of ODEs
 
      
-sympy.solvers.ode.systems.linodesolve_type(A, t, b=None)[source]
      
+sympy.solvers.ode.systems.linodesolve_type(A, t, b=None)[source]
 
      Helper function that determines the type of the system of ODEs for solving with sympy.solvers.ode.systems.linodesolve()
      
 
      
 
      Parameters:
      
@@ -3929,7 +3929,7 @@ 
      System of ODEs
 
      
-sympy.solvers.ode.systems.matrix_exp_jordan_form(A, t)[source]
      
+sympy.solvers.ode.systems.matrix_exp_jordan_form(A, t)[source]
 
      Matrix exponential \(\exp(A*t)\) for the matrix A and scalar t.
      
 
      
 
      Parameters:
      
@@ -3990,7 +3990,7 @@ 
      System of ODEs
 
      
-sympy.solvers.ode.systems.matrix_exp(A, t)[source]
      
+sympy.solvers.ode.systems.matrix_exp(A, t)[source]
 
      Matrix exponential \(\exp(A*t)\) for the matrix A and scalar t.
      
 
      
 
      Parameters:
      
@@ -4086,7 +4086,7 @@ 
      System of ODEstau=None,
      
 
      
 
-)[source]
+)[source]
 
      System of n equations linear first-order differential equations
      
 
      
 
      Parameters:
      
@@ -4305,7 +4305,7 @@ 
      System of ODEs
 
      
-sympy.solvers.ode.ode._nonlinear_2eq_order1_type1(x, y, t, eq)[source]
      
+sympy.solvers.ode.ode._nonlinear_2eq_order1_type1(x, y, t, eq)[source]
 
      Equations:
      
 
      
 
      
@@ -4336,7 +4336,7 @@ 
      System of ODEs
 
      
-sympy.solvers.ode.ode._nonlinear_2eq_order1_type2(x, y, t, eq)[source]
      
+sympy.solvers.ode.ode._nonlinear_2eq_order1_type2(x, y, t, eq)[source]
 
      Equations:
      
 
      
 
      
@@ -4367,7 +4367,7 @@ 
      System of ODEs
 
      
-sympy.solvers.ode.ode._nonlinear_2eq_order1_type3(x, y, t, eq)[source]
      
+sympy.solvers.ode.ode._nonlinear_2eq_order1_type3(x, y, t, eq)[source]
 
      Autonomous system of general form
      
 
      
 
      
@@ -4392,7 +4392,7 @@ 
      System of ODEs
 
      
-sympy.solvers.ode.ode._nonlinear_2eq_order1_type4(x, y, t, eq)[source]
      
+sympy.solvers.ode.ode._nonlinear_2eq_order1_type4(x, y, t, eq)[source]
 
      Equation:
      
 
      
 
      
@@ -4415,7 +4415,7 @@ 
      System of ODEs
 
      
-sympy.solvers.ode.ode._nonlinear_2eq_order1_type5(func, t, eq)[source]
      
+sympy.solvers.ode.ode._nonlinear_2eq_order1_type5(func, t, eq)[source]
 
      Clairaut system of ODEs
      
 
      
 
      
@@ -4439,7 +4439,7 @@ 
      System of ODEs
 
      
-sympy.solvers.ode.ode._nonlinear_3eq_order1_type1(x, y, z, t, eq)[source]
      
+sympy.solvers.ode.ode._nonlinear_3eq_order1_type1(x, y, z, t, eq)[source]
 
      Equations:
      
 
      
 
      
@@ -4464,7 +4464,7 @@ 
      System of ODEs
 
      
-sympy.solvers.ode.ode._nonlinear_3eq_order1_type2(x, y, z, t, eq)[source]
      
+sympy.solvers.ode.ode._nonlinear_3eq_order1_type2(x, y, z, t, eq)[source]
 
      Equations:
      
 
      
 
      
@@ -4497,7 +4497,7 @@ 
      System of ODEs
 
      
-sympy.solvers.ode.ode._nonlinear_3eq_order1_type3(x, y, z, t, eq)[source]
      
+sympy.solvers.ode.ode._nonlinear_3eq_order1_type3(x, y, z, t, eq)[source]
 
      Equations:
      
 
      
 
      
@@ -4527,7 +4527,7 @@ 
      System of ODEs
 
      
-sympy.solvers.ode.ode._nonlinear_3eq_order1_type4(x, y, z, t, eq)[source]
      
+sympy.solvers.ode.ode._nonlinear_3eq_order1_type4(x, y, z, t, eq)[source]
 
      Equations:
      
 
      
 
      
@@ -4557,7 +4557,7 @@ 
      System of ODEs
 
      
-sympy.solvers.ode.ode._nonlinear_3eq_order1_type5(x, y, z, t, eq)[source]
      
+sympy.solvers.ode.ode._nonlinear_3eq_order1_type5(x, y, z, t, eq)[source]
 
      
 
      
 \[x' = x (c F_2 - b F_3), \enspace y' = y (a F_3 - c F_1), \enspace z' = z (b F_1 - a F_2)\]
      
@@ -4795,7 +4795,7 @@ 
      System of ODEs
 
      
-sympy.solvers.ode.ode._handle_Integral(expr, func, hint)[source]
      
+sympy.solvers.ode.ode._handle_Integral(expr, func, hint)[source]
 
      Converts a solution with Integrals in it into an actual solution.
      
 
      For most hints, this simply runs expr.doit().
      
 
      
diff --git a/dev/modules/solvers/pde.html b/dev/modules/solvers/pde.html
index 6fe44b05800..dc488cdd56d 100644
--- a/dev/modules/solvers/pde.html
+++ b/dev/modules/solvers/pde.html
@@ -805,7 +805,7 @@ 
      User Functionsfrom sympy import *.  They are intended for user use.
      
 
      
 
      
-sympy.solvers.pde.pde_separate(eq, fun, sep, strategy='mul')[source]
      
+sympy.solvers.pde.pde_separate(eq, fun, sep, strategy='mul')[source]
 
      Separate variables in partial differential equation either by additive
 or multiplicative separation approach. It tries to rewrite an equation so
 that one of the specified variables occurs on a different side of the
@@ -846,7 +846,7 @@ 
      User Functions
 
      
-sympy.solvers.pde.pde_separate_add(eq, fun, sep)[source]
      
+sympy.solvers.pde.pde_separate_add(eq, fun, sep)[source]
 
      Helper function for searching additive separable solutions.
      
 
      Consider an equation of two independent variables x, y and a dependent
 variable w, we look for the product of two functions depending on different
@@ -867,7 +867,7 @@ 
      User Functions
 
      
-sympy.solvers.pde.pde_separate_mul(eq, fun, sep)[source]
      
+sympy.solvers.pde.pde_separate_mul(eq, fun, sep)[source]
 
      Helper function for searching multiplicative separable solutions.
      
 
      Consider an equation of two independent variables x, y and a dependent
 variable w, we look for the product of two functions depending on different
@@ -899,7 +899,7 @@ 
      User Functions**kwargs,
      
 
      
 
-)[source]
+)[source]
 
      Solves any (supported) kind of partial differential equation.
      
 
      Usage
      
 
      
@@ -1012,7 +1012,7 @@ 
      User Functions**kwargs,
      
 
      
 
-)[source]
+)[source]
 
      Returns a tuple of possible pdsolve() classifications for a PDE.
      
 
      The tuple is ordered so that first item is the classification that
 pdsolve() uses to solve the PDE by default.  In general,
@@ -1055,7 +1055,7 @@ 
      User Functionssolve_for_func=True,
      
 
      
 
-)[source]
+)[source]
 
      Checks if the given solution satisfies the partial differential
 equation.
      
 
      pde is the partial differential equation which can be given in the
@@ -1109,7 +1109,7 @@ 
      Hint Methodssolvefun,
      
 
      
 
-)[source]
+)[source]
 
      Solves a first order linear homogeneous
 partial differential equation with constant coefficients.
      
 
      The general form of this partial differential equation is
      
@@ -1179,7 +1179,7 @@ 
      Hint Methodssolvefun,
      
 
      
 
-)[source]
+)[source]
 
      Solves a first order linear partial differential equation
 with constant coefficients.
      
 
      The general form of this partial differential equation is
      
@@ -1264,7 +1264,7 @@ 
      Hint Methodssolvefun,
      
 
      
 
-)[source]
+)[source]
 
      Solves a first order linear partial differential equation
 with variable coefficients. The general form of this partial
 differential equation is
      
diff --git a/dev/modules/solvers/solvers.html b/dev/modules/solvers/solvers.html
index 38c60c05c8a..7b9fe420210 100644
--- a/dev/modules/solvers/solvers.html
+++ b/dev/modules/solvers/solvers.html
@@ -832,7 +832,7 @@ 
      Documentation Version
      
 is the symbol that we want to solve the equation for.
      
 
      
 
      
-sympy.solvers.solvers.solve(f, *symbols, **flags)[source]
      
+sympy.solvers.solvers.solve(f, *symbols, **flags)[source]
 
      Algebraically solves equations and systems of equations.
      
 
      
 
      Parameters:
      
@@ -1322,7 +1322,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.solvers.solvers.solve_linear(lhs, rhs=0, symbols=[], exclude=[])[source]
      
+sympy.solvers.solvers.solve_linear(lhs, rhs=0, symbols=[], exclude=[])[source]
 
      Return a tuple derived from f = lhs - rhs that is one of
 the following: (0, 1), (0, 0), (symbol, solution), (n, d).
      
 
      Explanation
      
@@ -1422,7 +1422,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.solvers.solvers.solve_linear_system(system, *symbols, **flags)[source]
      
+sympy.solvers.solvers.solve_linear_system(system, *symbols, **flags)[source]
 
      Solve system of \(N\) linear equations with \(M\) variables, which means
 both under- and overdetermined systems are supported.
      
 
      Explanation
      
@@ -1465,7 +1465,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.solvers.solvers.solve_linear_system_LU(matrix, syms)[source]
      
+sympy.solvers.solvers.solve_linear_system_LU(matrix, syms)[source]
 
      Solves the augmented matrix system using LUsolve and returns a
 dictionary in which solutions are keyed to the symbols of syms as ordered.
      
 
      Explanation
      
@@ -1499,7 +1499,7 @@ 
      Documentation Version
      
 
      **flags,
      
 
      
 
-)[source]
+)[source]
 
      Solve a system of equations in \(k\) parameters that is formed by
 matching coefficients in variables coeffs that are on
 factors dependent on the remaining variables (or those given
@@ -1562,7 +1562,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.solvers.solvers.nsolve(*args, dict=False, **kwargs)[source]
      
+sympy.solvers.solvers.nsolve(*args, dict=False, **kwargs)[source]
 
      Solve a nonlinear equation system numerically: nsolve(f, [args,] x0,
 modules=['mpmath'], **kwargs).
      
 
      Explanation
      
@@ -1664,7 +1664,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.solvers.solvers.checksol(f, symbol, sol=None, **flags)[source]
      
+sympy.solvers.solvers.checksol(f, symbol, sol=None, **flags)[source]
 
      Checks whether sol is a solution of equation f == 0.
      
 
      Explanation
      
 
      Input can be either a single symbol and corresponding value
@@ -1712,7 +1712,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.solvers.solvers.unrad(eq, *syms, **flags)[source]
      
+sympy.solvers.solvers.unrad(eq, *syms, **flags)[source]
 
      Remove radicals with symbolic arguments and return (eq, cov),
 None, or raise an error.
      
 
      Explanation
      
@@ -1787,7 +1787,7 @@ 
      Partial Differential Equations (PDEs)
      
 
      
 
      
-sympy.solvers.deutils.ode_order(expr, func)[source]
      
+sympy.solvers.deutils.ode_order(expr, func)[source]
 
      Returns the order of a given differential
 equation with respect to func.
      
 
      This function is implemented recursively.
      
@@ -1812,7 +1812,7 @@ 
      Deutils (Utilities for solving ODE’s and PDE’s)
      Recurrence Equations
      
 
      
 
      
-sympy.solvers.recurr.rsolve(f, y, init=None)[source]
      
+sympy.solvers.recurr.rsolve(f, y, init=None)[source]
 
      Solve univariate recurrence with rational coefficients.
      
 
      Given \(k\)-th order linear recurrence \(\operatorname{L} y = f\),
 or equivalently:
      
@@ -1868,7 +1868,7 @@ 
      Deutils (Utilities for solving ODE’s and PDE’s)
 
      
-sympy.solvers.recurr.rsolve_poly(coeffs, f, n, shift=0, **hints)[source]
      
+sympy.solvers.recurr.rsolve_poly(coeffs, f, n, shift=0, **hints)[source]
 
      Given linear recurrence operator \(\operatorname{L}\) of order
 \(k\) with polynomial coefficients and inhomogeneous equation
 \(\operatorname{L} y = f\), where \(f\) is a polynomial, we seek for
@@ -1929,7 +1929,7 @@ 
      Deutils (Utilities for solving ODE’s and PDE’s)
 
      
-sympy.solvers.recurr.rsolve_ratio(coeffs, f, n, **hints)[source]
      
+sympy.solvers.recurr.rsolve_ratio(coeffs, f, n, **hints)[source]
 
      Given linear recurrence operator \(\operatorname{L}\) of order \(k\)
 with polynomial coefficients and inhomogeneous equation
 \(\operatorname{L} y = f\), where \(f\) is a polynomial, we seek
@@ -1982,7 +1982,7 @@ 
      Deutils (Utilities for solving ODE’s and PDE’s)
 
      
-sympy.solvers.recurr.rsolve_hyper(coeffs, f, n, **hints)[source]
      
+sympy.solvers.recurr.rsolve_hyper(coeffs, f, n, **hints)[source]
 
      Given linear recurrence operator \(\operatorname{L}\) of order \(k\)
 with polynomial coefficients and inhomogeneous equation
 \(\operatorname{L} y = f\) we seek for all hypergeometric solutions
@@ -2054,7 +2054,7 @@ 
      Systems of Polynomial Equations**args,
      
 
      
 
-)[source]
+)[source]
 
      Return a list of solutions for the system of polynomial equations
 or else None.
      
 
      
@@ -2110,7 +2110,7 @@ 
      Systems of Polynomial Equations
 
      
-sympy.solvers.polysys.solve_triangulated(polys, *gens, **args)[source]
      
+sympy.solvers.polysys.solve_triangulated(polys, *gens, **args)[source]
 
      Solve a polynomial system using Gianni-Kalkbrenner algorithm.
      
 
      The algorithm proceeds by computing one Groebner basis in the ground
 domain and then by iteratively computing polynomial factorizations in
@@ -2170,7 +2170,7 @@ 
      Inequalities
      Linear Programming (Optimization)
      
 
      
 
      
-sympy.solvers.simplex.lpmax(f, constr)[source]
      
+sympy.solvers.simplex.lpmax(f, constr)[source]
 
      return maximum of linear equation f under
 linear constraints expressed using Ge, Le or Eq.
      
 
      All variables are unbounded unless constrained.
      
@@ -2204,7 +2204,7 @@ 
      Inequalities
 
      
-sympy.solvers.simplex.lpmin(f, constr)[source]
      
+sympy.solvers.simplex.lpmin(f, constr)[source]
 
      return minimum of linear equation f under
 linear constraints expressed using Ge, Le or Eq.
      
 
      All variables are unbounded unless constrained.
      
@@ -2251,7 +2251,7 @@ 
      Inequalitiesbounds=None,
      
 
      
 
-)[source]
+)[source]
 
      Return the minimization of c*x with the given
 constraints A*x <= b and A_eq*x = b_eq. Unless bounds
 are given, variables will have nonnegative values in the solution.
      
diff --git a/dev/modules/solvers/solveset.html b/dev/modules/solvers/solveset.html
index fe7c1876a1d..b0354ffe602 100644
--- a/dev/modules/solvers/solveset.html
+++ b/dev/modules/solvers/solveset.html
@@ -1323,7 +1323,7 @@ 
      Solveset Module Reference
 
      
-sympy.solvers.solveset.solveset(f, symbol=None, domain=Complexes)[source]
      
+sympy.solvers.solveset.solveset(f, symbol=None, domain=Complexes)[source]
 
      Solves a given inequality or equation with set as output
      
 
      
 
      Parameters:
      
@@ -1439,24 +1439,24 @@ 
      Solveset Module Reference
 
      
-sympy.solvers.solveset.solveset_real(f, symbol)[source]
      
+sympy.solvers.solveset.solveset_real(f, symbol)[source]
 
      
 
 
      
 
      
-sympy.solvers.solveset.solveset_complex(f, symbol)[source]
      
+sympy.solvers.solveset.solveset_complex(f, symbol)[source]
 
      
 
 
      
 
      
-sympy.solvers.solveset.invert_real(f_x, y, x)[source]
      
+sympy.solvers.solveset.invert_real(f_x, y, x)[source]
 
      Inverts a real-valued function. Same as invert_complex(), but sets
 the domain to S.Reals before inverting.
      
 
      
 
 
      
 
      
-sympy.solvers.solveset.invert_complex(f_x, y, x, domain=Complexes)[source]
      
+sympy.solvers.solveset.invert_complex(f_x, y, x, domain=Complexes)[source]
 
      Reduce the complex valued equation \(f(x) = y\) to a set of equations
      
 
      
 
      
@@ -1512,7 +1512,7 @@ 
      Solveset Module Reference
 
      
-sympy.solvers.solveset.domain_check(f, symbol, p)[source]
      
+sympy.solvers.solveset.domain_check(f, symbol, p)[source]
 
      Returns False if point p is infinite or any subexpression of f
 is infinite or becomes so after replacing symbol with p. If none of
 these conditions is met then True will be returned.
      
@@ -1548,7 +1548,7 @@ 
      Solveset Module Reference
 
      
-sympy.solvers.solveset.solvify(f, symbol, domain)[source]
      
+sympy.solvers.solveset.solvify(f, symbol, domain)[source]
 
      Solves an equation using solveset and returns the solution in accordance
 with the \(solve\) output API.
      
 
      
@@ -1590,7 +1590,7 @@ 
      Solveset Module Reference
 
      
-sympy.solvers.solveset.linear_eq_to_matrix(equations, *symbols)[source]
      
+sympy.solvers.solveset.linear_eq_to_matrix(equations, *symbols)[source]
 
      Converts a given System of Equations into Matrix form.
 Here \(equations\) must be a linear system of equations in
 \(symbols\). Element M[i, j] corresponds to the coefficient
@@ -1680,7 +1680,7 @@ 
      Solveset Module Reference
 
      
-sympy.solvers.solveset.linsolve(system, *symbols)[source]
      
+sympy.solvers.solveset.linsolve(system, *symbols)[source]
 
      Solve system of \(N\) linear equations with \(M\) variables; both
 underdetermined and overdetermined systems are supported.
 The possible number of solutions is zero, one or infinite.
@@ -1876,7 +1876,7 @@ 
      Solveset Module Reference
 
      
-sympy.solvers.solveset.nonlinsolve(system, *symbols)[source]
      
+sympy.solvers.solveset.nonlinsolve(system, *symbols)[source]
 
      Solve system of \(N\) nonlinear equations with \(M\) variables, which means both
 under and overdetermined systems are supported. Positive dimensional
 system is also supported (A system with infinitely many solutions is said
@@ -2034,7 +2034,7 @@ 
      Solveset Module Reference
      
 
      
 
      
-sympy.solvers.solveset._transolve(f, symbol, domain)[source]
      
+sympy.solvers.solveset._transolve(f, symbol, domain)[source]
 
      Function to solve transcendental equations. It is a helper to
 solveset and should be used internally. _transolve
 currently supports the following class of equations:
      
@@ -2207,7 +2207,7 @@ 
      transolve
 
      
-sympy.solvers.solveset._is_exponential(f, symbol)[source]
      
+sympy.solvers.solveset._is_exponential(f, symbol)[source]
 
      Return True if one or more terms contain symbol only in
 exponents, else False.
      
 
      
@@ -2247,7 +2247,7 @@ 
      transolve
 
      
-sympy.solvers.solveset._solve_exponential(lhs, rhs, symbol, domain)[source]
      
+sympy.solvers.solveset._solve_exponential(lhs, rhs, symbol, domain)[source]
 
      Helper function for solving (supported) exponential equations.
      
 
      Exponential equations are the sum of (currently) at most
 two terms with one or both of them having a power with a
@@ -2327,7 +2327,7 @@ 
      transolve
 
      
-sympy.solvers.solveset._solve_logarithm(lhs, rhs, symbol, domain)[source]
      
+sympy.solvers.solveset._solve_logarithm(lhs, rhs, symbol, domain)[source]
 
      Helper to solve logarithmic equations which are reducible
 to a single instance of \(\log\).
      
 
      Logarithmic equations are (currently) the equations that contains
@@ -2418,7 +2418,7 @@ 
      transolve
 
      
-sympy.solvers.solveset._is_logarithmic(f, symbol)[source]
      
+sympy.solvers.solveset._is_logarithmic(f, symbol)[source]
 
      Return True if the equation is in the form
 \(a\log(f(x)) + b\log(g(x)) + ... + c\) else False.
      
 
      
diff --git a/dev/modules/stats.html b/dev/modules/stats.html
index cd92e53514c..60baa47c771 100644
--- a/dev/modules/stats.html
+++ b/dev/modules/stats.html
@@ -925,7 +925,7 @@ 
      Random Variable TypesFinite Types
      
 
      
 
      
-sympy.stats.DiscreteUniform(name, items)[source]
      
+sympy.stats.DiscreteUniform(name, items)[source]
 
      Create a Finite Random Variable representing a uniform distribution over
 the input set.
      
 
      
@@ -969,7 +969,7 @@ 
      Finite Types
 
      
-sympy.stats.Die(name, sides=6)[source]
      
+sympy.stats.Die(name, sides=6)[source]
 
      Create a Finite Random Variable representing a fair die.
      
 
      
 
      Parameters:
      
@@ -1009,7 +1009,7 @@ 
      Finite Types
 
      
-sympy.stats.Bernoulli(name, p, succ=1, fail=0)[source]
      
+sympy.stats.Bernoulli(name, p, succ=1, fail=0)[source]
 
      Create a Finite Random Variable representing a Bernoulli process.
      
 
      
 
      Parameters:
      
@@ -1060,7 +1060,7 @@ 
      Finite Types
 
      
-sympy.stats.Coin(name, p=1 / 2)[source]
      
+sympy.stats.Coin(name, p=1 / 2)[source]
 
      Create a Finite Random Variable representing a Coin toss.
      
 
      This is an equivalent of a Bernoulli random variable with
 “H” and “T” as success and failure events respectively.
      
@@ -1105,7 +1105,7 @@ 
      Finite Types
 
      
-sympy.stats.Binomial(name, n, p, succ=1, fail=0)[source]
      
+sympy.stats.Binomial(name, n, p, succ=1, fail=0)[source]
 
      Create a Finite Random Variable representing a binomial distribution.
      
 
      
 
      Parameters:
      
@@ -1164,7 +1164,7 @@ 
      Finite Types
 
      
-sympy.stats.BetaBinomial(name, n, alpha, beta)[source]
      
+sympy.stats.BetaBinomial(name, n, alpha, beta)[source]
 
      Create a Finite Random Variable representing a Beta-binomial distribution.
      
 
      
 
      Parameters:
      
@@ -1203,7 +1203,7 @@ 
      Finite Types
 
      
-sympy.stats.Hypergeometric(name, N, m, n)[source]
      
+sympy.stats.Hypergeometric(name, N, m, n)[source]
 
      Create a Finite Random Variable representing a hypergeometric distribution.
      
 
      
 
      Parameters:
      
@@ -1248,7 +1248,7 @@ 
      Finite Types
 
      
-sympy.stats.FiniteRV(name, density, **kwargs)[source]
      
+sympy.stats.FiniteRV(name, density, **kwargs)[source]
 
      Create a Finite Random Variable given a dict representing the density.
      
 
      
 
      Parameters:
      
@@ -1289,7 +1289,7 @@ 
      Finite Types
 
      
-sympy.stats.Rademacher(name)[source]
      
+sympy.stats.Rademacher(name)[source]
 
      Create a Finite Random Variable representing a Rademacher distribution.
      
 
      
 
      Returns:
      
@@ -1323,7 +1323,7 @@ 
      Finite Types
      
 
      
 
      
-sympy.stats.Geometric(name, p)[source]
      
+sympy.stats.Geometric(name, p)[source]
 
      Create a discrete random variable with a Geometric distribution.
      
 
      
 
      Parameters:
      
@@ -1378,7 +1378,7 @@ 
      Discrete Types
 
      
-sympy.stats.Hermite(name, a1, a2)[source]
      
+sympy.stats.Hermite(name, a1, a2)[source]
 
      Create a discrete random variable with a Hermite distribution.
      
 
      
 
      Parameters:
      
@@ -1432,7 +1432,7 @@ 
      Discrete Types
 
      
-sympy.stats.Poisson(name, lamda)[source]
      
+sympy.stats.Poisson(name, lamda)[source]
 
      Create a discrete random variable with a Poisson distribution.
      
 
      
 
      Parameters:
      
@@ -1487,7 +1487,7 @@ 
      Discrete Types
 
      
-sympy.stats.Logarithmic(name, p)[source]
      
+sympy.stats.Logarithmic(name, p)[source]
 
      Create a discrete random variable with a Logarithmic distribution.
      
 
      
 
      Parameters:
      
@@ -1542,7 +1542,7 @@ 
      Discrete Types
 
      
-sympy.stats.NegativeBinomial(name, r, p)[source]
      
+sympy.stats.NegativeBinomial(name, r, p)[source]
 
      Create a discrete random variable with a Negative Binomial distribution.
      
 
      
 
      Parameters:
      
@@ -1599,7 +1599,7 @@ 
      Discrete Types
 
      
-sympy.stats.Skellam(name, mu1, mu2)[source]
      
+sympy.stats.Skellam(name, mu1, mu2)[source]
 
      Create a discrete random variable with a Skellam distribution.
      
 
      
 
      Parameters:
      
@@ -1654,7 +1654,7 @@ 
      Discrete Types
 
      
-sympy.stats.YuleSimon(name, rho)[source]
      
+sympy.stats.YuleSimon(name, rho)[source]
 
      Create a discrete random variable with a Yule-Simon distribution.
      
 
      
 
      Parameters:
      
@@ -1705,7 +1705,7 @@ 
      Discrete Types
 
      
-sympy.stats.Zeta(name, s)[source]
      
+sympy.stats.Zeta(name, s)[source]
 
      Create a discrete random variable with a Zeta distribution.
      
 
      
 
      Parameters:
      
@@ -1759,7 +1759,7 @@ 
      Discrete Types
      
 
      
 
      
-sympy.stats.Arcsin(name, a=0, b=1)[source]
      
+sympy.stats.Arcsin(name, a=0, b=1)[source]
 
      Create a Continuous Random Variable with an arcsin distribution.
      
 
      The density of the arcsin distribution is given by
      
 
      
@@ -1810,7 +1810,7 @@ 
      Continuous Types
 
      
-sympy.stats.Benini(name, alpha, beta, sigma)[source]
      
+sympy.stats.Benini(name, alpha, beta, sigma)[source]
 
      Create a Continuous Random Variable with a Benini distribution.
      
 
      The density of the Benini distribution is given by
      
 
      
@@ -1874,7 +1874,7 @@ 
      Continuous Types
 
      
-sympy.stats.Beta(name, alpha, beta)[source]
      
+sympy.stats.Beta(name, alpha, beta)[source]
 
      Create a Continuous Random Variable with a Beta distribution.
      
 
      The density of the Beta distribution is given by
      
 
      
@@ -1935,7 +1935,7 @@ 
      Continuous Types
 
      
-sympy.stats.BetaNoncentral(name, alpha, beta, lamda)[source]
      
+sympy.stats.BetaNoncentral(name, alpha, beta, lamda)[source]
 
      Create a Continuous Random Variable with a Type I Noncentral Beta distribution.
      
 
      The density of the Noncentral Beta distribution is given by
      
 
      
@@ -2006,7 +2006,7 @@ 
      Continuous Types
 
      
-sympy.stats.BetaPrime(name, alpha, beta)[source]
      
+sympy.stats.BetaPrime(name, alpha, beta)[source]
 
      Create a continuous random variable with a Beta prime distribution.
      
 
      The density of the Beta prime distribution is given by
      
 
      
@@ -2059,7 +2059,7 @@ 
      Continuous Types
 
      
-sympy.stats.BoundedPareto(name, alpha, left, right)[source]
      
+sympy.stats.BoundedPareto(name, alpha, left, right)[source]
 
      Create a continuous random variable with a Bounded Pareto distribution.
      
 
      The density of the Bounded Pareto distribution is given by
      
 
      
@@ -2110,7 +2110,7 @@ 
      Continuous Types
 
      
-sympy.stats.Cauchy(name, x0, gamma)[source]
      
+sympy.stats.Cauchy(name, x0, gamma)[source]
 
      Create a continuous random variable with a Cauchy distribution.
      
 
      The density of the Cauchy distribution is given by
      
 
      
@@ -2158,7 +2158,7 @@ 
      Continuous Types
 
      
-sympy.stats.Chi(name, k)[source]
      
+sympy.stats.Chi(name, k)[source]
 
      Create a continuous random variable with a Chi distribution.
      
 
      The density of the Chi distribution is given by
      
 
      
@@ -2209,7 +2209,7 @@ 
      Continuous Types
 
      
-sympy.stats.ChiNoncentral(name, k, l)[source]
      
+sympy.stats.ChiNoncentral(name, k, l)[source]
 
      Create a continuous random variable with a non-central Chi distribution.
      
 
      
 
      Parameters:
      
@@ -2263,7 +2263,7 @@ 
      Continuous Types
 
      
-sympy.stats.ChiSquared(name, k)[source]
      
+sympy.stats.ChiSquared(name, k)[source]
 
      Create a continuous random variable with a Chi-squared distribution.
      
 
      
 
      Parameters:
      
@@ -2327,7 +2327,7 @@ 
      Continuous Types
 
      
-sympy.stats.Dagum(name, p, a, b)[source]
      
+sympy.stats.Dagum(name, p, a, b)[source]
 
      Create a continuous random variable with a Dagum distribution.
      
 
      
 
      Parameters:
      
@@ -2389,7 +2389,7 @@ 
      Continuous Types
 
      
-sympy.stats.Davis(name, b, n, mu)[source]
      
+sympy.stats.Davis(name, b, n, mu)[source]
 
      Create a continuous random variable with Davis distribution.
      
 
      
 
      Parameters:
      
@@ -2445,7 +2445,7 @@ 
      Continuous Types
 
      
-sympy.stats.Erlang(name, k, l)[source]
      
+sympy.stats.Erlang(name, k, l)[source]
 
      Create a continuous random variable with an Erlang distribution.
      
 
      
 
      Parameters:
      
@@ -2516,7 +2516,7 @@ 
      Continuous Types
 
      
-sympy.stats.ExGaussian(name, mean, std, rate)[source]
      
+sympy.stats.ExGaussian(name, mean, std, rate)[source]
 
      Create a continuous random variable with an Exponentially modified
 Gaussian (EMG) distribution.
      
 
      
@@ -2603,7 +2603,7 @@ 
      Continuous Types
 
      
-sympy.stats.Exponential(name, rate)[source]
      
+sympy.stats.Exponential(name, rate)[source]
 
      Create a continuous random variable with an Exponential distribution.
      
 
      
 
      Parameters:
      
@@ -2686,7 +2686,7 @@ 
      Continuous Types
 
      
-sympy.stats.FDistribution(name, d1, d2)[source]
      
+sympy.stats.FDistribution(name, d1, d2)[source]
 
      Create a continuous random variable with a F distribution.
      
 
      
 
      Parameters:
      
@@ -2746,7 +2746,7 @@ 
      Continuous Types
 
      
-sympy.stats.FisherZ(name, d1, d2)[source]
      
+sympy.stats.FisherZ(name, d1, d2)[source]
 
      Create a Continuous Random Variable with an Fisher’s Z distribution.
      
 
      
 
      Parameters:
      
@@ -2811,7 +2811,7 @@ 
      Continuous Types
 
      
-sympy.stats.Frechet(name, a, s=1, m=0)[source]
      
+sympy.stats.Frechet(name, a, s=1, m=0)[source]
 
      Create a continuous random variable with a Frechet distribution.
      
 
      
 
      Parameters:
      
@@ -2864,7 +2864,7 @@ 
      Continuous Types
 
      
-sympy.stats.Gamma(name, k, theta)[source]
      
+sympy.stats.Gamma(name, k, theta)[source]
 
      Create a continuous random variable with a Gamma distribution.
      
 
      
 
      Parameters:
      
@@ -2941,7 +2941,7 @@ 
      Continuous Types
 
      
-sympy.stats.GammaInverse(name, a, b)[source]
      
+sympy.stats.GammaInverse(name, a, b)[source]
 
      Create a continuous random variable with an inverse Gamma distribution.
      
 
      
 
      Parameters:
      
@@ -2998,7 +2998,7 @@ 
      Continuous Types
 
      
-sympy.stats.Gompertz(name, b, eta)[source]
      
+sympy.stats.Gompertz(name, b, eta)[source]
 
      Create a Continuous Random Variable with Gompertz distribution.
      
 
      
 
      Parameters:
      
@@ -3044,7 +3044,7 @@ 
      Continuous Types
 
      
-sympy.stats.Gumbel(name, beta, mu, minimum=False)[source]
      
+sympy.stats.Gumbel(name, beta, mu, minimum=False)[source]
 
      Create a Continuous Random Variable with Gumbel distribution.
      
 
      
 
      Parameters:
      
@@ -3107,7 +3107,7 @@ 
      Continuous Types
 
      
-sympy.stats.Kumaraswamy(name, a, b)[source]
      
+sympy.stats.Kumaraswamy(name, a, b)[source]
 
      Create a Continuous Random Variable with a Kumaraswamy distribution.
      
 
      
 
      Parameters:
      
@@ -3160,7 +3160,7 @@ 
      Continuous Types
 
      
-sympy.stats.Laplace(name, mu, b)[source]
      
+sympy.stats.Laplace(name, mu, b)[source]
 
      Create a continuous random variable with a Laplace distribution.
      
 
      
 
      Parameters:
      
@@ -3227,7 +3227,7 @@ 
      Continuous Types
 
      
-sympy.stats.Levy(name, mu, c)[source]
      
+sympy.stats.Levy(name, mu, c)[source]
 
      Create a continuous random variable with a Levy distribution.
      
 
      The density of the Levy distribution is given by
      
 
      
@@ -3285,7 +3285,7 @@ 
      Continuous Types
 
      
-sympy.stats.Logistic(name, mu, s)[source]
      
+sympy.stats.Logistic(name, mu, s)[source]
 
      Create a continuous random variable with a logistic distribution.
      
 
      
 
      Parameters:
      
@@ -3338,7 +3338,7 @@ 
      Continuous Types
 
      
-sympy.stats.LogLogistic(name, alpha, beta)[source]
      
+sympy.stats.LogLogistic(name, alpha, beta)[source]
 
      Create a continuous random variable with a log-logistic distribution.
 The distribution is unimodal when beta > 1.
      
 
      
@@ -3404,7 +3404,7 @@ 
      Continuous Types
 
      
-sympy.stats.LogNormal(name, mean, std)[source]
      
+sympy.stats.LogNormal(name, mean, std)[source]
 
      Create a continuous random variable with a log-normal distribution.
      
 
      
 
      Parameters:
      
@@ -3477,7 +3477,7 @@ 
      Continuous Types
 
      
-sympy.stats.Lomax(name, alpha, lamda)[source]
      
+sympy.stats.Lomax(name, alpha, lamda)[source]
 
      Create a continuous random variable with a Lomax distribution.
      
 
      
 
      Parameters:
      
@@ -3527,7 +3527,7 @@ 
      Continuous Types
 
      
-sympy.stats.Maxwell(name, a)[source]
      
+sympy.stats.Maxwell(name, a)[source]
 
      Create a continuous random variable with a Maxwell distribution.
      
 
      
 
      Parameters:
      
@@ -3583,7 +3583,7 @@ 
      Continuous Types
 
      
-sympy.stats.Moyal(name, mu, sigma)[source]
      
+sympy.stats.Moyal(name, mu, sigma)[source]
 
      Create a continuous random variable with a Moyal distribution.
      
 
      
 
      Parameters:
      
@@ -3635,7 +3635,7 @@ 
      Continuous Types
 
      
-sympy.stats.Nakagami(name, mu, omega)[source]
      
+sympy.stats.Nakagami(name, mu, omega)[source]
 
      Create a continuous random variable with a Nakagami distribution.
      
 
      
 
      Parameters:
      
@@ -3706,7 +3706,7 @@ 
      Continuous Types
 
      
-sympy.stats.Normal(name, mean, std)[source]
      
+sympy.stats.Normal(name, mean, std)[source]
 
      Create a continuous random variable with a Normal distribution.
      
 
      
 
      Parameters:
      
@@ -3804,7 +3804,7 @@ 
      Continuous Types
 
      
-sympy.stats.Pareto(name, xm, alpha)[source]
      
+sympy.stats.Pareto(name, xm, alpha)[source]
 
      Create a continuous random variable with the Pareto distribution.
      
 
      
 
      Parameters:
      
@@ -3854,7 +3854,7 @@ 
      Continuous Types
 
      
-sympy.stats.PowerFunction(name, alpha, a, b)[source]
      
+sympy.stats.PowerFunction(name, alpha, a, b)[source]
 
      Creates a continuous random variable with a Power Function Distribution.
      
 
      
 
      Parameters:
      
@@ -3919,7 +3919,7 @@ 
      Continuous Types
 
      
-sympy.stats.QuadraticU(name, a, b)[source]
      
+sympy.stats.QuadraticU(name, a, b)[source]
 
      Create a Continuous Random Variable with a U-quadratic distribution.
      
 
      
 
      Parameters:
      
@@ -3974,7 +3974,7 @@ 
      Continuous Types
 
      
-sympy.stats.RaisedCosine(name, mu, s)[source]
      
+sympy.stats.RaisedCosine(name, mu, s)[source]
 
      Create a Continuous Random Variable with a raised cosine distribution.
      
 
      
 
      Parameters:
      
@@ -4027,7 +4027,7 @@ 
      Continuous Types
 
      
-sympy.stats.Rayleigh(name, sigma)[source]
      
+sympy.stats.Rayleigh(name, sigma)[source]
 
      Create a continuous random variable with a Rayleigh distribution.
      
 
      
 
      Parameters:
      
@@ -4083,7 +4083,7 @@ 
      Continuous Types
 
      
-sympy.stats.Reciprocal(name, a, b)[source]
      
+sympy.stats.Reciprocal(name, a, b)[source]
 
      Creates a continuous random variable with a reciprocal distribution.
      
 
      
 
      Parameters:
      
@@ -4118,7 +4118,7 @@ 
      Continuous Types
 
      
-sympy.stats.StudentT(name, nu)[source]
      
+sympy.stats.StudentT(name, nu)[source]
 
      Create a continuous random variable with a student’s t distribution.
      
 
      
 
      Parameters:
      
@@ -4183,7 +4183,7 @@ 
      Continuous Types
 
      
-sympy.stats.ShiftedGompertz(name, b, eta)[source]
      
+sympy.stats.ShiftedGompertz(name, b, eta)[source]
 
      Create a continuous random variable with a Shifted Gompertz distribution.
      
 
      
 
      Parameters:
      
@@ -4229,7 +4229,7 @@ 
      Continuous Types
 
      
-sympy.stats.Trapezoidal(name, a, b, c, d)[source]
      
+sympy.stats.Trapezoidal(name, a, b, c, d)[source]
 
      Create a continuous random variable with a trapezoidal distribution.
      
 
      
 
      Parameters:
      
@@ -4296,7 +4296,7 @@ 
      Continuous Types
 
      
-sympy.stats.Triangular(name, a, b, c)[source]
      
+sympy.stats.Triangular(name, a, b, c)[source]
 
      Create a continuous random variable with a triangular distribution.
      
 
      
 
      Parameters:
      
@@ -4365,7 +4365,7 @@ 
      Continuous Types
 
      
-sympy.stats.Uniform(name, left, right)[source]
      
+sympy.stats.Uniform(name, left, right)[source]
 
      Create a continuous random variable with a uniform distribution.
      
 
      
 
      Parameters:
      
@@ -4430,7 +4430,7 @@ 
      Continuous Types
 
      
-sympy.stats.UniformSum(name, n)[source]
      
+sympy.stats.UniformSum(name, n)[source]
 
      Create a continuous random variable with an Irwin-Hall distribution.
      
 
      
 
      Parameters:
      
@@ -4500,7 +4500,7 @@ 
      Continuous Types
 
      
-sympy.stats.VonMises(name, mu, k)[source]
      
+sympy.stats.VonMises(name, mu, k)[source]
 
      Create a Continuous Random Variable with a von Mises distribution.
      
 
      
 
      Parameters:
      
@@ -4560,7 +4560,7 @@ 
      Continuous Types
 
      
-sympy.stats.Wald(name, mean, shape)[source]
      
+sympy.stats.Wald(name, mean, shape)[source]
 
      Create a continuous random variable with an Inverse Gaussian distribution.
 Inverse Gaussian distribution is also known as Wald distribution.
      
 
      
@@ -4635,7 +4635,7 @@ 
      Continuous Types
 
      
-sympy.stats.Weibull(name, alpha, beta)[source]
      
+sympy.stats.Weibull(name, alpha, beta)[source]
 
      Create a continuous random variable with a Weibull distribution.
      
 
      
 
      Parameters:
      
@@ -4696,7 +4696,7 @@ 
      Continuous Types
 
      
-sympy.stats.WignerSemicircle(name, R)[source]
      
+sympy.stats.WignerSemicircle(name, R)[source]
 
      Create a continuous random variable with a Wigner semicircle distribution.
      
 
      
 
      Parameters:
      
@@ -4757,7 +4757,7 @@ 
      Continuous Types**kwargs,
      
 
      
 
-)[source]
+)[source]
 
      Create a Continuous Random Variable given the following:
      
 
      
 
      Parameters:
      
@@ -4811,7 +4811,7 @@ 
      Continuous Types
      
 
      
 
      
-sympy.stats.JointRV(symbol, pdf, _set=None)[source]
      
+sympy.stats.JointRV(symbol, pdf, _set=None)[source]
 
      Create a Joint Random Variable where each of its component is continuous,
 given the following:
      
 
      
@@ -4846,7 +4846,7 @@ 
      Joint Types
 
      
-sympy.stats.marginal_distribution(rv, *indices)[source]
      
+sympy.stats.marginal_distribution(rv, *indices)[source]
 
      Marginal distribution function of a joint random variable.
      
 
      
 
      Parameters:
      
@@ -4871,7 +4871,7 @@ 
      Joint Types
 
      
-sympy.stats.MultivariateNormal(name, mu, sigma)[source]
      
+sympy.stats.MultivariateNormal(name, mu, sigma)[source]
 
      Creates a continuous random variable with Multivariate Normal
 Distribution.
      
 
      The density of the multivariate normal distribution can be found at [1].
      
@@ -4929,7 +4929,7 @@ 
      Joint Types
 
      
-sympy.stats.MultivariateLaplace(name, mu, sigma)[source]
      
+sympy.stats.MultivariateLaplace(name, mu, sigma)[source]
 
      Creates a continuous random variable with Multivariate Laplace
 Distribution.
      
 
      The density of the multivariate Laplace distribution can be found at [1].
      
@@ -4977,7 +4977,7 @@ 
      Joint Typesmu,
      
 
      
 
-)[source]
+)[source]
 
      Creates a joint random variable with generalized multivariate log gamma
 distribution.
      
 
      The joint pdf can be found at [1].
      
@@ -5040,7 +5040,7 @@ 
      Joint Typesmu,
      
 
      
 
-)[source]
+)[source]
 
      Extends GeneralizedMultivariateLogGamma.
      
 
      
 
      Parameters:
      
@@ -5096,7 +5096,7 @@ 
      Joint Types
 
      
-sympy.stats.Multinomial(syms, n, *p)[source]
      
+sympy.stats.Multinomial(syms, n, *p)[source]
 
      Creates a discrete random variable with Multinomial Distribution.
      
 
      The density of the said distribution can be found at [1].
      
 
      
@@ -5142,7 +5142,7 @@ 
      Joint Types
 
      
-sympy.stats.MultivariateBeta(syms, *alpha)[source]
      
+sympy.stats.MultivariateBeta(syms, *alpha)[source]
 
      Creates a continuous random variable with Dirichlet/Multivariate Beta
 Distribution.
      
 
      The density of the Dirichlet distribution can be found at [1].
      
@@ -5187,7 +5187,7 @@ 
      Joint Types
 
      
-sympy.stats.MultivariateEwens(syms, n, theta)[source]
      
+sympy.stats.MultivariateEwens(syms, n, theta)[source]
 
      Creates a discrete random variable with Multivariate Ewens
 Distribution.
      
 
      The density of the said distribution can be found at [1].
      
@@ -5233,7 +5233,7 @@ 
      Joint Types
 
      
-sympy.stats.MultivariateT(syms, mu, sigma, v)[source]
      
+sympy.stats.MultivariateT(syms, mu, sigma, v)[source]
 
      Creates a joint random variable with multivariate T-distribution.
      
 
      
 
      Parameters:
      
@@ -5268,7 +5268,7 @@ 
      Joint Types
 
      
-sympy.stats.NegativeMultinomial(syms, k0, *p)[source]
      
+sympy.stats.NegativeMultinomial(syms, k0, *p)[source]
 
      Creates a discrete random variable with Negative Multinomial Distribution.
      
 
      The density of the said distribution can be found at [1].
      
 
      
@@ -5315,7 +5315,7 @@ 
      Joint Types
 
      
-sympy.stats.NormalGamma(sym, mu, lamda, alpha, beta)[source]
      
+sympy.stats.NormalGamma(sym, mu, lamda, alpha, beta)[source]
 
      Creates a bivariate joint random variable with multivariate Normal gamma
 distribution.
      
 
      
@@ -5380,7 +5380,7 @@ 
      Joint Typestrans_probs=None,
      
 
      
 
-)[source]
+)[source]
 
      Represents a finite discrete time-homogeneous Markov chain.
      
 
      This type of Markov Chain can be uniquely characterised by
 its (ordered) state space and its one-step transition probability
@@ -5507,7 +5507,7 @@ 
      Joint Types
 
      
-absorbing_probabilities()[source]
      
+absorbing_probabilities()[source]
 
      Computes the absorbing probabilities, i.e.
 the ij-th entry of the matrix denotes the
 probability of Markov chain being absorbed
@@ -5516,7 +5516,7 @@ 
      Joint Types
 
      
-canonical_form() → Tuple[List[Basic], ImmutableDenseMatrix][source]
      
+canonical_form() → Tuple[List[Basic], ImmutableDenseMatrix][source]
 
      Reorders the one-step transition matrix
 so that recurrent states appear first and transient
 states appear last. Other representations include inserting
@@ -5618,7 +5618,7 @@ 
      Joint Types
 
      
-communication_classes() → List[Tuple[List[Basic], Boolean, Integer]][source]
      
+communication_classes() → List[Tuple[List[Basic], Boolean, Integer]][source]
 
      Returns the list of communication classes that partition
 the states of the markov chain.
      
 
      A communication class is defined to be a set of states
@@ -5690,7 +5690,7 @@ 
      Joint Types
 
      
-decompose() → Tuple[List[Basic], ImmutableDenseMatrix, ImmutableDenseMatrix, ImmutableDenseMatrix][source]
      
+decompose() → Tuple[List[Basic], ImmutableDenseMatrix, ImmutableDenseMatrix, ImmutableDenseMatrix][source]
 
      Decomposes the transition matrix into submatrices with
 special properties.
      
 
      The transition matrix can be decomposed into 4 submatrices:
@@ -5773,13 +5773,13 @@ 
      Joint Types
 
      
-fixed_row_vector()[source]
      
+fixed_row_vector()[source]
 
      A wrapper for stationary_distribution().
      
 
      
 
 
      
 
      
-fundamental_matrix()[source]
      
+fundamental_matrix()[source]
 
      Each entry fundamental matrix can be interpreted as
 the expected number of times the chains is in state j
 if it started in state i.
      
@@ -5801,7 +5801,7 @@ 
      Joint Types
 
      
-sample()[source]
      
+sample()[source]
 
      
 
      Returns:
      
 
      sample: iterator object
      
@@ -5820,7 +5820,7 @@ 
      Joint Typescondition_set=False,
      
 
      
 
-) → ImmutableDenseMatrix | ConditionSet | Lambda[source]
+) → ImmutableDenseMatrix | ConditionSet | Lambda[source]
 
      The stationary distribution is any row vector, p, that solves p = pP,
 is row stochastic and each element in p must be nonnegative.
 That means in matrix form: \((P-I)^T p^T = 0\) and
@@ -5908,7 +5908,7 @@ 
      Joint Typesgen_mat=None,
      
 
      
 
-)[source]
+)[source]
 
      Represents continuous time Markov chain.
      
 
      
 
      Parameters:
      
@@ -5993,7 +5993,7 @@ 
      Joint Types
 
      
-class sympy.stats.BernoulliProcess(sym, p, success=1, failure=0)[source]
      
+class sympy.stats.BernoulliProcess(sym, p, success=1, failure=0)[source]
 
      The Bernoulli process consists of repeated
 independent Bernoulli process trials with the same parameter \(p\).
 It’s assumed that the probability \(p\) applies to every
@@ -6072,7 +6072,7 @@ 
      Joint Types**kwargs,
      
 
      
 
-)[source]
+)[source]
 
      Computes expectation.
      
 
      
 
      Parameters:
      
@@ -6103,7 +6103,7 @@ 
      Joint Types**kwargs,
      
 
      
 
-)[source]
+)[source]
 
      Computes probability.
      
 
      
 
      Parameters:
      
@@ -6127,7 +6127,7 @@ 
      Joint Types
 
      
-class sympy.stats.PoissonProcess(sym, lamda)[source]
      
+class sympy.stats.PoissonProcess(sym, lamda)[source]
 
      The Poisson process is a counting process. It is usually used in scenarios
 where we are counting the occurrences of certain events that appear
 to happen at a certain rate, but completely at random.
      
@@ -6197,7 +6197,7 @@ 
      Joint Types
 
      
-class sympy.stats.WienerProcess(sym)[source]
      
+class sympy.stats.WienerProcess(sym)[source]
 
      The Wiener process is a real valued continuous-time stochastic process.
 In physics it is used to study Brownian motion and it is often also called
 Brownian motion due to its historical connection with physical process of the
@@ -6240,7 +6240,7 @@ 
      Joint Types
 
      
-class sympy.stats.GammaProcess(sym, lamda, gamma)[source]
      
+class sympy.stats.GammaProcess(sym, lamda, gamma)[source]
 
      A Gamma process is a random process with independent gamma distributed
 increments. It is a pure-jump increasing Levy process.
      
 
      
@@ -6289,7 +6289,7 @@ 
      Joint Types
      
 
      
 
      
-sympy.stats.MatrixGamma(symbol, alpha, beta, scale_matrix)[source]
      
+sympy.stats.MatrixGamma(symbol, alpha, beta, scale_matrix)[source]
 
      Creates a random variable with Matrix Gamma Distribution.
      
 
      The density of the said distribution can be found at [1].
      
 
      
@@ -6336,7 +6336,7 @@ 
      Matrix Distributions
 
      
-sympy.stats.Wishart(symbol, n, scale_matrix)[source]
      
+sympy.stats.Wishart(symbol, n, scale_matrix)[source]
 
      Creates a random variable with Wishart Distribution.
      
 
      The density of the said distribution can be found at [1].
      
 
      
@@ -6388,7 +6388,7 @@ 
      Matrix Distributionsscale_matrix_2,
      
 
      
 
-)[source]
+)[source]
 
      Creates a random variable with Matrix Normal Distribution.
      
 
      The density of the said distribution can be found at [1].
      
 
      
@@ -6437,7 +6437,7 @@ 
      Matrix DistributionsCompound Distribution
      
 
      
 
      
-class sympy.stats.compound_rv.CompoundDistribution(dist)[source]
      
+class sympy.stats.compound_rv.CompoundDistribution(dist)[source]
 
      Class for Compound Distributions.
      
 
      
 
      Parameters:
      
@@ -6486,7 +6486,7 @@ 
      Interface**kwargs,
      
 
      
 
-)[source]
+)[source]
 
      Probability that a condition is true, optionally given a second condition.
      
 
      
 
      Parameters:
      
@@ -6525,7 +6525,7 @@ 
      Interface
 
      
-class sympy.stats.Probability(prob, condition=None, **kwargs)[source]
      
+class sympy.stats.Probability(prob, condition=None, **kwargs)[source]
 
      Symbolic expression for the probability.
      
 
      Examples
      
 
      >>> from sympy.stats import Probability, Normal
@@ -6560,7 +6560,7 @@ 
      Interface**kwargs,
      
 
      
 
-)[source]
+)[source]
 
      Returns the expected value of a random expression.
      
 
      
 
      Parameters:
      
@@ -6603,7 +6603,7 @@ 
      Interface
 
      
-class sympy.stats.Expectation(expr, condition=None, **kwargs)[source]
      
+class sympy.stats.Expectation(expr, condition=None, **kwargs)[source]
 
      Symbolic expression for the expectation.
      
 
      Examples
      
 
      >>> from sympy.stats import Expectation, Normal, Probability, Poisson
@@ -6682,7 +6682,7 @@ 
      Interface**kwargs,
      
 
      
 
-)[source]
+)[source]
 
      Probability density of a random expression, optionally given a second
 condition.
      
 
      
@@ -6728,7 +6728,7 @@ 
      Interface
 
      
-sympy.stats.entropy(expr, condition=None, **kwargs)[source]
      
+sympy.stats.entropy(expr, condition=None, **kwargs)[source]
 
      Calculuates entropy of a probability distribution.
      
 
      
 
      Parameters:
      
@@ -6774,7 +6774,7 @@ 
      Interface
 
      
-sympy.stats.given(expr, condition=None, **kwargs)[source]
      
+sympy.stats.given(expr, condition=None, **kwargs)[source]
 
      Conditional Random Expression.
      
 
      Explanation
      
 
      From a random expression and a condition on that expression creates a new
@@ -6812,7 +6812,7 @@ 
      Interface
 
      
-sympy.stats.where(condition, given_condition=None, **kwargs)[source]
      
+sympy.stats.where(condition, given_condition=None, **kwargs)[source]
 
      Returns the domain where a condition is True.
      
 
      Examples
      
 
      >>> from sympy.stats import where, Die, Normal
@@ -6840,7 +6840,7 @@ 
      Interface
 
      
-sympy.stats.variance(X, condition=None, **kwargs)[source]
      
+sympy.stats.variance(X, condition=None, **kwargs)[source]
 
      Variance of a random expression.
      
 
      
 
      
@@ -6868,7 +6868,7 @@ 
      Interface
 
      
-class sympy.stats.Variance(arg, condition=None, **kwargs)[source]
      
+class sympy.stats.Variance(arg, condition=None, **kwargs)[source]
 
      Symbolic expression for the variance.
      
 
      Examples
      
 
      >>> from sympy import symbols, Integral
@@ -6917,7 +6917,7 @@ 
      Interface
 
      
-sympy.stats.covariance(X, Y, condition=None, **kwargs)[source]
      
+sympy.stats.covariance(X, Y, condition=None, **kwargs)[source]
 
      Covariance of two random expressions.
      
 
      Explanation
      
 
      The expectation that the two variables will rise and fall together
      
@@ -6947,7 +6947,7 @@ 
      Interface
 
      
-class sympy.stats.Covariance(arg1, arg2, condition=None, **kwargs)[source]
      
+class sympy.stats.Covariance(arg1, arg2, condition=None, **kwargs)[source]
 
      Symbolic expression for the covariance.
      
 
      Examples
      
 
      >>> from sympy.stats import Covariance
@@ -6992,7 +6992,7 @@ 
      Interface
 
      
-sympy.stats.coskewness(X, Y, Z, condition=None, **kwargs)[source]
      
+sympy.stats.coskewness(X, Y, Z, condition=None, **kwargs)[source]
 
      Calculates the co-skewness of three random variables.
      
 
      
 
      Parameters:
      
@@ -7052,7 +7052,7 @@ 
      Interface
 
      
-sympy.stats.median(X, evaluate=True, **kwargs)[source]
      
+sympy.stats.median(X, evaluate=True, **kwargs)[source]
 
      Calculuates the median of the probability distribution.
      
 
      
 
      Parameters:
      
@@ -7091,7 +7091,7 @@ 
      Interface
 
      
-sympy.stats.std(X, condition=None, **kwargs)[source]
      
+sympy.stats.std(X, condition=None, **kwargs)[source]
 
      Standard Deviation of a random expression
      
 
      
 
      
@@ -7114,7 +7114,7 @@ 
      Interface
 
      
-sympy.stats.quantile(expr, evaluate=True, **kwargs)[source]
      
+sympy.stats.quantile(expr, evaluate=True, **kwargs)[source]
 
      Return the \(p^{th}\) order quantile of a probability distribution.
      
 
      Explanation
      
 
      Quantile is defined as the value at which the probability of the random
@@ -7168,7 +7168,7 @@ 
      Interface**kwargs,
      
 
      
 
-)[source]
+)[source]
 
      A realization of the random expression.
      
 
      
 
      Parameters:
      
@@ -7289,7 +7289,7 @@ 
      Interface**kwargs,
      
 
      
 
-)[source]
+)[source]
 
      Returns an iterator of realizations from the expression given a condition.
      
 
      
 
      Parameters:
      
@@ -7348,7 +7348,7 @@ 
      Interface
 
      
-sympy.stats.factorial_moment(X, n, condition=None, **kwargs)[source]
      
+sympy.stats.factorial_moment(X, n, condition=None, **kwargs)[source]
 
      The factorial moment is a mathematical quantity defined as the expectation
 or average of the falling factorial of a random variable.
      
 
      
@@ -7393,7 +7393,7 @@ 
      Interface
 
      
-sympy.stats.kurtosis(X, condition=None, **kwargs)[source]
      
+sympy.stats.kurtosis(X, condition=None, **kwargs)[source]
 
      Characterizes the tails/outliers of a probability distribution.
      
 
      
 
      Parameters:
      
@@ -7442,7 +7442,7 @@ 
      Interface
 
      
-sympy.stats.skewness(X, condition=None, **kwargs)[source]
      
+sympy.stats.skewness(X, condition=None, **kwargs)[source]
 
      Measure of the asymmetry of the probability distribution.
      
 
      
 
      Parameters:
      
@@ -7479,7 +7479,7 @@ 
      Interface
 
      
-sympy.stats.correlation(X, Y, condition=None, **kwargs)[source]
      
+sympy.stats.correlation(X, Y, condition=None, **kwargs)[source]
 
      Correlation of two random expressions, also known as correlation
 coefficient or Pearson’s correlation.
      
 
      Explanation
      
@@ -7522,7 +7522,7 @@ 
      Interface**kwargs,
      
 
      
 
-)[source]
+)[source]
 
      Sampling version of density.
      
 
      
 
      See also
      
@@ -7544,7 +7544,7 @@ 
      Interface**kwargs,
      
 
      
 
-)[source]
+)[source]
 
      Sampling version of P.
      
 
      
 
      See also
      
@@ -7566,7 +7566,7 @@ 
      Interface**kwargs,
      
 
      
 
-)[source]
+)[source]
 
      Sampling version of E.
      
 
      
 
      See also
      
@@ -7576,7 +7576,7 @@ 
      Interface
 
      
-class sympy.stats.Moment(X, n, c=0, condition=None, **kwargs)[source]
      
+class sympy.stats.Moment(X, n, c=0, condition=None, **kwargs)[source]
 
      Symbolic class for Moment
      
 
      Examples
      
 
      >>> from sympy import Symbol, Integral
@@ -7623,7 +7623,7 @@ 
      Interface**kwargs,
      
 
      
 
-)[source]
+)[source]
 
      Return the nth moment of a random expression about c.
      
 
      
 
      
@@ -7645,7 +7645,7 @@ 
      Interface
 
      
-class sympy.stats.CentralMoment(X, n, condition=None, **kwargs)[source]
      
+class sympy.stats.CentralMoment(X, n, condition=None, **kwargs)[source]
 
      Symbolic class Central Moment
      
 
      Examples
      
 
      >>> from sympy import Symbol, Integral
@@ -7691,7 +7691,7 @@ 
      Interface**kwargs,
      
 
      
 
-)[source]
+)[source]
 
      Return the nth central moment of a random expression about its mean.
      
 
      
 
      
@@ -7712,7 +7712,7 @@ 
      Interface
 
      
-class sympy.stats.ExpectationMatrix(expr, condition=None)[source]
      
+class sympy.stats.ExpectationMatrix(expr, condition=None)[source]
 
      Expectation of a random matrix expression.
      
 
      Examples
      
 
      >>> from sympy.stats import ExpectationMatrix, Normal
@@ -7751,7 +7751,7 @@ 
      Interface
 
      
-class sympy.stats.VarianceMatrix(arg, condition=None)[source]
      
+class sympy.stats.VarianceMatrix(arg, condition=None)[source]
 
      Variance of a random matrix probability expression. Also known as
 Covariance matrix, auto-covariance matrix, dispersion matrix,
 or variance-covariance matrix.
      
@@ -7779,7 +7779,7 @@ 
      Interface
 
      
-class sympy.stats.CrossCovarianceMatrix(arg1, arg2, condition=None)[source]
      
+class sympy.stats.CrossCovarianceMatrix(arg1, arg2, condition=None)[source]
 
      Covariance of a random matrix probability expression.
      
 
      Examples
      
 
      >>> from sympy.stats import CrossCovarianceMatrix
@@ -7818,7 +7818,7 @@ 
      Interface\(\{1,2,3,4,5,6\}\).
      
 
      
 
      
-class sympy.stats.rv.RandomDomain[source]
      
+class sympy.stats.rv.RandomDomain[source]
 
      
 
 
      A PSpace, or Probability Space, combines a RandomDomain
@@ -7828,13 +7828,13 @@ 
      Interfacex.
      
 
      
 
      
-class sympy.stats.rv.PSpace[source]
      
+class sympy.stats.rv.PSpace[source]
 
      
 
 
      A RandomSymbol represents the PSpace’s symbol ‘x’ inside of SymPy expressions.
      
 
      
 
      
-class sympy.stats.rv.RandomSymbol[source]
      
+class sympy.stats.rv.RandomSymbol[source]
 
      
 
 
      The RandomDomain and PSpace classes are almost never directly instantiated.
@@ -7846,12 +7846,12 @@ 
      Interface
 
      
-class sympy.stats.rv.SinglePSpace[source]
      
+class sympy.stats.rv.SinglePSpace[source]
 
      
 
 
      
 
      
-class sympy.stats.rv.SingleDomain[source]
      
+class sympy.stats.rv.SingleDomain[source]
 
      
 
 
      Another common case is to collect together a set of such univariate random
@@ -7860,12 +7860,12 @@ 
      Interface
 
      
-class sympy.stats.rv.ProductDomain[source]
      
+class sympy.stats.rv.ProductDomain[source]
 
      
 
 
      
 
      
-class sympy.stats.rv.ProductPSpace[source]
      
+class sympy.stats.rv.ProductPSpace[source]
 
      
 
 
      The Conditional adjective is added whenever we add a global condition to a
@@ -7873,7 +7873,7 @@ 
      Interface
 
      
-class sympy.stats.rv.ConditionalDomain[source]
      
+class sympy.stats.rv.ConditionalDomain[source]
 
      
 
 
      We specialize further into Finite and Continuous versions of these classes to
@@ -7881,22 +7881,22 @@ 
      Interface
 
      
-class sympy.stats.frv.FiniteDomain[source]
      
+class sympy.stats.frv.FiniteDomain[source]
 
      
 
 
      
 
      
-class sympy.stats.frv.FinitePSpace[source]
      
+class sympy.stats.frv.FinitePSpace[source]
 
      
 
 
      
 
      
-class sympy.stats.crv.ContinuousDomain[source]
      
+class sympy.stats.crv.ContinuousDomain[source]
 
      
 
 
      
 
      
-class sympy.stats.crv.ContinuousPSpace[source]
      
+class sympy.stats.crv.ContinuousPSpace[source]
 
      
 
 
      Additionally there are a few specialized classes that implement certain common
@@ -7940,13 +7940,13 @@ 
      Interface
 
      
-sympy.stats.rv.random_symbols(expr)[source]
      
+sympy.stats.rv.random_symbols(expr)[source]
 
      Returns all RandomSymbols within a SymPy Expression.
      
 
      
 
 
      
 
      
-sympy.stats.rv.pspace(expr)[source]
      
+sympy.stats.rv.pspace(expr)[source]
 
      Returns the underlying Probability Space of a random expression.
      
 
      For internal use.
      
 
      Examples
      
@@ -7960,7 +7960,7 @@ 
      Interface
 
      
-sympy.stats.rv.rs_swap(a, b)[source]
      
+sympy.stats.rv.rs_swap(a, b)[source]
 
      Build a dictionary to swap RandomSymbols based on their underlying symbol.
      
 
      i.e.
 if    X = ('x', pspace1)
diff --git a/dev/modules/tensor/array.html b/dev/modules/tensor/array.html
index 99fb87313be..8275254dd46 100644
--- a/dev/modules/tensor/array.html
+++ b/dev/modules/tensor/array.html
@@ -1042,7 +1042,7 @@ 
      Classes
      **kwargs,
      
 
      
 
-)[source]
+)[source]
 
      
 
 
      
@@ -1055,7 +1055,7 @@ 
      Classes
      **kwargs,
      
 
      
 
-)[source]
+)[source]
 
      
 
 
      
@@ -1068,7 +1068,7 @@ 
      Classes
      **kwargs,
      
 
      
 
-)[source]
+)[source]
 
      
 
 
      
@@ -1081,7 +1081,7 @@ 
      Classes
      **kwargs,
      
 
      
 
-)[source]
+)[source]
 
      
 
 
@@ -1089,7 +1089,7 @@ 
      Classes
      Functions
      
 
      
 
      
-sympy.tensor.array.derive_by_array(expr, dx)[source]
      
+sympy.tensor.array.derive_by_array(expr, dx)[source]
 
      Derivative by arrays. Supports both arrays and scalars.
      
 
      The equivalent operator for array expressions is array_derive.
      
 
      Explanation
      
@@ -1121,7 +1121,7 @@ 
      Functionsindex_order_new=None,
      
 
      
 
-)[source]
+)[source]
 
      Permutes the indices of an array.
      
 
      Parameter specifies the permutation of the indices.
      
 
      The equivalent operator for array expressions is PermuteDims, which can
@@ -1174,7 +1174,7 @@ 
      Functions
 
      
-sympy.tensor.array.tensorcontraction(array, *contraction_axes)[source]
      
+sympy.tensor.array.tensorcontraction(array, *contraction_axes)[source]
 
      Contraction of an array-like object on the specified axes.
      
 
      The equivalent operator for array expressions is ArrayContraction,
 which can be used to keep the expression unevaluated.
      
@@ -1215,7 +1215,7 @@ 
      Functions
 
      
-sympy.tensor.array.tensorproduct(*args)[source]
      
+sympy.tensor.array.tensorproduct(*args)[source]
 
      Tensor product among scalars or array-like objects.
      
 
      The equivalent operator for array expressions is ArrayTensorProduct,
 which can be used to keep the expression unevaluated.
      
@@ -1248,7 +1248,7 @@ 
      Functions
 
      
-sympy.tensor.array.tensordiagonal(array, *diagonal_axes)[source]
      
+sympy.tensor.array.tensordiagonal(array, *diagonal_axes)[source]
 
      Diagonalization of an array-like object on the specified axes.
      
 
      This is equivalent to multiplying the expression by Kronecker deltas
 uniting the axes.
      
diff --git a/dev/modules/tensor/array_expressions.html b/dev/modules/tensor/array_expressions.html
index 0dd80a0f313..e919fa3ad63 100644
--- a/dev/modules/tensor/array_expressions.html
+++ b/dev/modules/tensor/array_expressions.html
@@ -965,7 +965,7 @@ 
      Compatibility with matrices
 
      
-class sympy.tensor.array.expressions.ArrayTensorProduct(*args, **kwargs)[source]
      
+class sympy.tensor.array.expressions.ArrayTensorProduct(*args, **kwargs)[source]
 
      Class to represent the tensor product of array-like objects.
      
 
      
 
@@ -979,14 +979,14 @@ 
      Compatibility with matrices**kwargs,
      
 
      
 
-)[source]
+)[source]
 
      This class is meant to represent contractions of arrays in a form easily
 processable by the code printers.
      
 
      
 
 
      
 
      
-class sympy.tensor.array.expressions.ArrayDiagonal(expr, *diagonal_indices, **kwargs)[source]
      
+class sympy.tensor.array.expressions.ArrayDiagonal(expr, *diagonal_indices, **kwargs)[source]
 
      Class to represent the diagonal operator.
      
 
      Explanation
      
 
      In a 2-dimensional array it returns the diagonal, this looks like the
@@ -1015,7 +1015,7 @@ 
      Compatibility with matrices**kwargs,
      
 
      
 
-)[source]
+)[source]
 
      Class to represent permutation of axes of arrays.
      
 
      Examples
      
 
      >>> from sympy.tensor.array import permutedims
diff --git a/dev/modules/tensor/index_methods.html b/dev/modules/tensor/index_methods.html
index 478def8e705..499d5165243 100644
--- a/dev/modules/tensor/index_methods.html
+++ b/dev/modules/tensor/index_methods.html
@@ -811,7 +811,7 @@ 
      Documentation Version
      
 refactoring.
      
 
      
 
      
-sympy.tensor.index_methods.get_contraction_structure(expr)[source]
      
+sympy.tensor.index_methods.get_contraction_structure(expr)[source]
 
      Determine dummy indices of expr and describe its structure
      
 
      By dummy we mean indices that are summation indices.
      
 
      The structure of the expression is determined and described as follows:
      
@@ -911,7 +911,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.tensor.index_methods.get_indices(expr)[source]
      
+sympy.tensor.index_methods.get_indices(expr)[source]
 
      Determine the outer indices of expression expr
      
 
      By outer we mean indices that are not summation indices.  Returns a set
 and a dict.  The set contains outer indices and the dict contains
diff --git a/dev/modules/tensor/indexed.html b/dev/modules/tensor/indexed.html
index e5ea4230948..b38c22055fe 100644
--- a/dev/modules/tensor/indexed.html
+++ b/dev/modules/tensor/indexed.html
@@ -885,7 +885,7 @@ 
      Examples
 
 
      
 
      
-class sympy.tensor.indexed.Idx(label, range=None, **kw_args)[source]
      
+class sympy.tensor.indexed.Idx(label, range=None, **kw_args)[source]
 
      Represents an integer index as an Integer or integer expression.
      
 
      There are a number of ways to create an Idx object.  The constructor
 takes two arguments:
      
@@ -991,7 +991,7 @@ 
      Examples
 
 
      
 
      
-class sympy.tensor.indexed.Indexed(base, *args, **kw_args)[source]
      
+class sympy.tensor.indexed.Indexed(base, *args, **kw_args)[source]
 
      Represents a mathematical object with indices.
      
 
      >>> from sympy import Indexed, IndexedBase, Idx, symbols
 >>> i, j = symbols('i j', cls=Idx)
@@ -1110,7 +1110,7 @@ 
      Examples
 
      **kw_args,
      
 
      
 
-)[source]
+)[source]
 
      Represent the base or stem of an indexed object
      
 
      The IndexedBase class represent an array that contains elements. The main purpose
 of this class is to allow the convenient creation of objects of the Indexed
diff --git a/dev/modules/tensor/tensor.html b/dev/modules/tensor/tensor.html
index a25271686fa..8557404ef99 100644
--- a/dev/modules/tensor/tensor.html
+++ b/dev/modules/tensor/tensor.html
@@ -814,7 +814,7 @@ 
      Documentation Version
      
 
      **kwargs,
      
 
      
 
-)[source]
+)[source]
 
      A TensorIndexType is characterized by its name and its metric.
      
 
      
 
      Parameters:
      
@@ -883,7 +883,7 @@ 
      Documentation Version
      
 
 
      
 
      
-class sympy.tensor.tensor.TensorIndex(name, tensor_index_type, is_up=True)[source]
      
+class sympy.tensor.tensor.TensorIndex(name, tensor_index_type, is_up=True)[source]
 
      Represents a tensor index
      
 
      
 
      Parameters:
      
@@ -945,7 +945,7 @@ 
      Documentation Version
      
 
      comm=0,
      
 
      
 
-)[source]
+)[source]
 
      Tensor head of the tensor.
      
 
      
 
      Parameters:
      
@@ -1064,7 +1064,7 @@ 
      Documentation Version
      
 
      
 
      
 
      
-commutes_with(other)[source]
      
+commutes_with(other)[source]
 
      Returns 0 if self and other commute, 1 if they anticommute.
      
 
      Returns None if self and other neither commute nor anticommute.
      
 
      
@@ -1082,13 +1082,13 @@ 
      Documentation Version
      
 
      comm=0,
      
 
      
 
-)[source]
+)[source]
 
      Returns a sequence of TensorHeads from a string \(s\)
      
 
      
 
 
      
 
      
-class sympy.tensor.tensor.TensExpr(*args)[source]
      
+class sympy.tensor.tensor.TensExpr(*args)[source]
 
      Abstract base class for tensor expressions
      
 
      Notes
      
 
      A tensor expression is an expression formed by tensors;
@@ -1103,7 +1103,7 @@ 
      Documentation Version
      
 
      Contracted indices are therefore nameless in the internal representation.
      
 
      
 
      
-get_matrix()[source]
      
+get_matrix()[source]
 
      DEPRECATED: do not use.
      
 
      Returns ndarray components data as a matrix, if components data are
 available and ndarray dimension does not exceed 2.
      
@@ -1118,7 +1118,7 @@ 
      Documentation Version
      
 
      indices=None,
      
 
      
 
-)[source]
+)[source]
 
      Replace the tensorial expressions with arrays. The final array will
 correspond to the N-dimensional array with indices arranged according
 to indices.
      
@@ -1193,7 +1193,7 @@ 
      Documentation Version
      
 
 
      
 
      
-class sympy.tensor.tensor.TensAdd(*args, **kw_args)[source]
      
+class sympy.tensor.tensor.TensAdd(*args, **kw_args)[source]
 
      Sum of tensors.
      
 
      
 
      Parameters:
      
@@ -1242,14 +1242,14 @@ 
      Documentation Version
      
 
      
 
      
 
      
-canon_bp()[source]
      
+canon_bp()[source]
 
      Canonicalize using the Butler-Portugal algorithm for canonicalization
 under monoterm symmetries.
      
 
      
 
 
      
 
      
-contract_metric(g)[source]
      
+contract_metric(g)[source]
 
      Raise or lower indices with the metric g.
      
 
      
 
      Parameters:
      
@@ -1265,7 +1265,7 @@ 
      Documentation Version
      
 
 
      
 
      
-class sympy.tensor.tensor.TensMul(*args, **kw_args)[source]
      
+class sympy.tensor.tensor.TensMul(*args, **kw_args)[source]
 
      Product of tensors.
      
 
      
 
      Parameters:
      
@@ -1319,7 +1319,7 @@ 
      Documentation Version
      
 
      
 
      
 
      
-canon_bp()[source]
      
+canon_bp()[source]
 
      Canonicalize using the Butler-Portugal algorithm for canonicalization
 under monoterm symmetries.
      
 
      Examples
      
@@ -1339,7 +1339,7 @@ 
      Documentation Version
      
 
 
      
 
      
-contract_metric(g)[source]
      
+contract_metric(g)[source]
 
      Raise or lower indices with the metric g.
      
 
      
 
      Parameters:
      
@@ -1365,7 +1365,7 @@ 
      Documentation Version
      
 
 
      
 
      
-get_free_indices() → list[TensorIndex][source]
      
+get_free_indices() → list[TensorIndex][source]
 
      Returns the list of free indices of the tensor.
      
 
      Explanation
      
 
      The indices are listed in the order in which they appear in the
@@ -1388,7 +1388,7 @@ 
      Documentation Version
      
 
 
      
 
      
-get_indices()[source]
      
+get_indices()[source]
 
      Returns the list of indices of the tensor.
      
 
      Explanation
      
 
      The indices are listed in the order in which they appear in the
@@ -1413,20 +1413,20 @@ 
      Documentation Version
      
 
 
      
 
      
-perm2tensor(g, is_canon_bp=False)[source]
      
+perm2tensor(g, is_canon_bp=False)[source]
 
      Returns the tensor corresponding to the permutation g
      
 
      For further details, see the method in TIDS with the same name.
      
 
      
 
 
      
 
      
-sorted_components()[source]
      
+sorted_components()[source]
 
      Returns a tensor product with sorted components.
      
 
      
 
 
      
 
      
-split()[source]
      
+split()[source]
 
      Returns a list of tensors, whose product is self.
      
 
      Explanation
      
 
      Dummy indices contracted among different tensor components
@@ -1450,21 +1450,21 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.tensor.tensor.canon_bp(p)[source]
      
+sympy.tensor.tensor.canon_bp(p)[source]
 
      Butler-Portugal canonicalization. See tensor_can.py from the
 combinatorics module for the details.
      
 
      
 
 
      
 
      
-sympy.tensor.tensor.riemann_cyclic_replace(t_r)[source]
      
+sympy.tensor.tensor.riemann_cyclic_replace(t_r)[source]
 
      replace Riemann tensor with an equivalent expression
      
 
      R(m,n,p,q) -> 2/3*R(m,n,p,q) - 1/3*R(m,q,n,p) + 1/3*R(m,p,n,q)
      
 
      
 
 
      
 
      
-sympy.tensor.tensor.riemann_cyclic(t2)[source]
      
+sympy.tensor.tensor.riemann_cyclic(t2)[source]
 
      Replace each Riemann tensor with an equivalent expression
 satisfying the cyclic identity.
      
 
      This trick is discussed in the reference guide to Cadabra.
      
@@ -1482,7 +1482,7 @@ 
      Documentation Version
      
 
 
      
 
      
-class sympy.tensor.tensor.TensorSymmetry(*args, **kw_args)[source]
      
+class sympy.tensor.tensor.TensorSymmetry(*args, **kw_args)[source]
 
      Monoterm symmetry of a tensor (i.e. any symmetric or anti-symmetric
 index permutation). For the relevant terminology see tensor_can.py
 section of the combinatorics module.
      
@@ -1533,7 +1533,7 @@ 
      Documentation Version
      
 
      
 
      
 
      
-classmethod direct_product(*args)[source]
      
+classmethod direct_product(*args)[source]
 
      Returns a TensorSymmetry object that is being a direct product of
 fully (anti-)symmetric index permutation groups.
      
 
      Notes
      
@@ -1547,20 +1547,20 @@ 
      Documentation Version
      
 
 
      
 
      
-classmethod fully_symmetric(rank)[source]
      
+classmethod fully_symmetric(rank)[source]
 
      Returns a fully symmetric (antisymmetric if rank``<0)
 TensorSymmetry object for ``abs(rank) indices.
      
 
      
 
 
      
 
      
-classmethod no_symmetry(rank)[source]
      
+classmethod no_symmetry(rank)[source]
 
      TensorSymmetry object for rank indices with no symmetry
      
 
      
 
 
      
 
      
-classmethod riemann()[source]
      
+classmethod riemann()[source]
 
      Returns a monotorem symmetry of the Riemann tensor
      
 
      
 
@@ -1568,7 +1568,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.tensor.tensor.tensorsymmetry(*args)[source]
      
+sympy.tensor.tensor.tensorsymmetry(*args)[source]
 
      Returns a TensorSymmetry object. This method is deprecated, use
 TensorSymmetry.direct_product() or .riemann() instead.
      
 
      Explanation
      
@@ -1597,7 +1597,7 @@ 
      Documentation Version
      
 
 
      
 
      
-class sympy.tensor.tensor.TensorType(*args, **kwargs)[source]
      
+class sympy.tensor.tensor.TensorType(*args, **kwargs)[source]
 
      Class of tensor types. Deprecated, use tensor_heads() instead.
      
 
      
 
      Parameters:
      
@@ -1625,7 +1625,7 @@ 
      Documentation Version
      
 
 
      
 
      
-class sympy.tensor.tensor._TensorManager[source]
      
+class sympy.tensor.tensor._TensorManager[source]
 
      Class to manage tensor properties.
      
 
      Notes
      
 
      Tensors belong to tensor commutation groups; each group has a label
@@ -1638,19 +1638,19 @@ 
      Documentation Version
      
 do not commute with any other group.
      
 
      
 
      
-clear()[source]
      
+clear()[source]
 
      Clear the TensorManager.
      
 
      
 
 
      
 
      
-comm_i2symbol(i)[source]
      
+comm_i2symbol(i)[source]
 
      Returns the symbol corresponding to the commutation group number.
      
 
      
 
 
      
 
      
-comm_symbols2i(i)[source]
      
+comm_symbols2i(i)[source]
 
      Get the commutation group number corresponding to i.
      
 
      i can be a symbol or a number or a string.
      
 
      If i is not already defined its commutation group number
@@ -1659,14 +1659,14 @@ 
      Documentation Version
      
 
 
      
 
      
-get_comm(i, j)[source]
      
+get_comm(i, j)[source]
 
      Return the commutation parameter for commutation group numbers i, j
      
 
      see _TensorManager.set_comm
      
 
      
 
 
      
 
      
-set_comm(i, j, c)[source]
      
+set_comm(i, j, c)[source]
 
      Set the commutation parameter c for commutation groups i, j.
      
 
      
 
      Parameters:
      
@@ -1708,7 +1708,7 @@ 
      Documentation Version
      
 
 
      
 
      
-set_comms(*args)[source]
      
+set_comms(*args)[source]
 
      Set the commutation group numbers c for symbols i, j.
      
 
      
 
      Parameters:
      
diff --git a/dev/modules/tensor/toperators.html b/dev/modules/tensor/toperators.html
index 01daad85469..135dca7a26c 100644
--- a/dev/modules/tensor/toperators.html
+++ b/dev/modules/tensor/toperators.html
@@ -802,7 +802,7 @@ 
      Documentation Version
      
 
      Tensor Operators
      
 
      
 
      
-class sympy.tensor.toperators.PartialDerivative(expr, *variables)[source]
      
+class sympy.tensor.toperators.PartialDerivative(expr, *variables)[source]
 
      Partial derivative for tensor expressions.
      
 
      Examples
      
 
      >>> from sympy.tensor.tensor import TensorIndexType, TensorHead
diff --git a/dev/modules/testing/pytest.html b/dev/modules/testing/pytest.html
index 16ff1e6a007..1250a6b0fec 100644
--- a/dev/modules/testing/pytest.html
+++ b/dev/modules/testing/pytest.html
@@ -803,19 +803,19 @@ 
      Documentation Version
      
 
      py.test hacks to support XFAIL/XPASS
      
 
      
 
      
-sympy.testing.pytest.SKIP(reason)[source]
      
+sympy.testing.pytest.SKIP(reason)[source]
 
      Similar to skip(), but this is a decorator.
      
 
      
 
 
      
 
      
-sympy.testing.pytest.nocache_fail(func)[source]
      
+sympy.testing.pytest.nocache_fail(func)[source]
 
      Dummy decorator for marking tests that fail when cache is disabled
      
 
      
 
 
      
 
      
-sympy.testing.pytest.raises(expectedException, code=None)[source]
      
+sympy.testing.pytest.raises(expectedException, code=None)[source]
 
      Tests that code raises the exception expectedException.
      
 
      code may be a callable, such as a lambda expression or function
 name.
      
@@ -867,7 +867,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.testing.pytest.skip_under_pyodide(message)[source]
      
+sympy.testing.pytest.skip_under_pyodide(message)[source]
 
      Decorator to skip a test if running under pyodide.
      
 
      
 
@@ -882,7 +882,7 @@ 
      Documentation Version
      
 
      test_stacklevel=True,
      
 
      
 
-)[source]
+)[source]
 
      Like raises but tests that warnings are emitted.
      
 
      >>> from sympy.testing.pytest import warns
 >>> import warnings
@@ -911,7 +911,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.testing.pytest.warns_deprecated_sympy()[source]
      
+sympy.testing.pytest.warns_deprecated_sympy()[source]
 
      Shorthand for warns(SymPyDeprecationWarning)
      
 
      This is the recommended way to test that SymPyDeprecationWarning is
 emitted for deprecated features in SymPy. To test for other warnings use
diff --git a/dev/modules/testing/runtests.html b/dev/modules/testing/runtests.html
index 2945ff1a5f9..25e3456149d 100644
--- a/dev/modules/testing/runtests.html
+++ b/dev/modules/testing/runtests.html
@@ -822,7 +822,7 @@ 
      Documentation Version
      
 
      split=None,
      
 
      
 
-)[source]
+)[source]
 
      Py.test like reporter. Should produce output identical to py.test.
      
 
      
 
      
@@ -836,7 +836,7 @@ 
      Documentation Version
      
 
      force_colors=False,
      
 
      
 
-)[source]
+)[source]
 
      Prints a text on the screen.
      
 
      It uses sys.stdout.write(), so no readline library is necessary.
      
 
      
@@ -856,7 +856,7 @@ 
      Documentation Version
      
 
 
      
 
      
-class sympy.testing.runtests.Reporter[source]
      
+class sympy.testing.runtests.Reporter[source]
 
      Parent class for all reporters.
      
 
      
 
@@ -871,7 +871,7 @@ 
      Documentation Version
      
 
      exclude_empty=True,
      
 
      
 
-)[source]
+)[source]
 
      A class used to extract the DocTests that are relevant to a given
 object, from its docstring and the docstrings of its contained
 objects.  Doctests can currently be extracted from the following
@@ -893,7 +893,7 @@ 
      Documentation Version
      
 
      optionflags=0,
      
 
      
 
-)[source]
+)[source]
 
      A class used to run DocTest test cases, and accumulate statistics.
 The run method is used to process a single DocTest case.  It
 returns a tuple (f, t), where t is the number of test cases
@@ -912,7 +912,7 @@ 
      Documentation Version
      
 
      clear_globs=True,
      
 
      
 
-)[source]
+)[source]
 
      Run the examples in test, and display the results using the
 writer function out.
      
 
      The examples are run in the namespace test.globs.  If
@@ -933,7 +933,7 @@ 
      Documentation Version
      
 
 
      
 
      
-class sympy.testing.runtests.SymPyOutputChecker[source]
      
+class sympy.testing.runtests.SymPyOutputChecker[source]
 
      Compared to the OutputChecker from the stdlib our OutputChecker class
 supports numerical comparison of floats occurring in the output of the
 doctest examples
      
@@ -947,7 +947,7 @@ 
      Documentation Version
      
 
      optionflags,
      
 
      
 
-)[source]
+)[source]
 
      Return True iff the actual output from an example (\(got\))
 matches the expected output (\(want\)).  These strings are
 always considered to match if they are identical; but
@@ -961,7 +961,7 @@ 
      Documentation Version
      
 
 
      
 
      
-class sympy.testing.runtests.SymPyTestResults(failed, attempted)[source]
      
+class sympy.testing.runtests.SymPyTestResults(failed, attempted)[source]
 
      
 
      
 attempted
      
@@ -978,7 +978,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.testing.runtests.convert_to_native_paths(lst)[source]
      
+sympy.testing.runtests.convert_to_native_paths(lst)[source]
 
      Converts a list of ‘/’ separated paths into a list of
 native (os.sep separated) paths and converts to lowercase
 if the system is case insensitive.
      
@@ -995,7 +995,7 @@ 
      Documentation Version
      
 
      **kwargs,
      
 
      
 
-)[source]
+)[source]
 
      Runs doctests in all *.py files in the SymPy directory which match
 any of the given strings in paths or all tests if paths=[].
      
 
      Notes:
      
@@ -1044,14 +1044,14 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.testing.runtests.get_sympy_dir()[source]
      
+sympy.testing.runtests.get_sympy_dir()[source]
 
      Returns the root SymPy directory and set the global value
 indicating whether the system is case sensitive or not.
      
 
      
 
 
      
 
      
-sympy.testing.runtests.raise_on_deprecated()[source]
      
+sympy.testing.runtests.raise_on_deprecated()[source]
 
      Context manager to make DeprecationWarning raise an error
      
 
      This is to catch SymPyDeprecationWarning from library code while running
 tests and doctests. It is important to use this context manager around
@@ -1072,7 +1072,7 @@ 
      Documentation Version
      
 
      examples_kwargs=None,
      
 
      
 
-)[source]
+)[source]
 
      Run all tests.
      
 
      Right now, this runs the regular tests (bin/test), the doctests
 (bin/doctest), and the examples (examples/all.py).
      
@@ -1101,7 +1101,7 @@ 
      Documentation Version
      
 
      force=False,
      
 
      
 
-)[source]
+)[source]
 
      Run a function in a Python subprocess with hash randomization enabled.
      
 
      If hash randomization is not supported by the version of Python given, it
 returns False.  Otherwise, it returns the exit value of the command.  The
@@ -1144,7 +1144,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.testing.runtests.split_list(l, split, density=None)[source]
      
+sympy.testing.runtests.split_list(l, split, density=None)[source]
 
      Splits a list into part a of b
      
 
      split should be a string of the form ‘a/b’. For instance, ‘1/3’ would give
 the split one of three.
      
@@ -1184,7 +1184,7 @@ 
      Documentation Version
      
 
      encoding=None,
      
 
      
 
-)[source]
+)[source]
 
      Test examples in the given file.  Return (#failures, #tests).
      
 
      Optional keyword arg module_relative specifies how filenames
 should be interpreted:
      
@@ -1252,7 +1252,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.testing.runtests.test(*paths, subprocess=True, rerun=0, **kwargs)[source]
      
+sympy.testing.runtests.test(*paths, subprocess=True, rerun=0, **kwargs)[source]
 
      Run tests in the specified test_*.py files.
      
 
      Tests in a particular test_*.py file are run if any of the given strings
 in paths matches a part of the test file’s path. If paths=[],
diff --git a/dev/modules/utilities/autowrap.html b/dev/modules/utilities/autowrap.html
index 524002a9b30..235566de504 100644
--- a/dev/modules/utilities/autowrap.html
+++ b/dev/modules/utilities/autowrap.html
@@ -937,17 +937,17 @@ 
      Implementation detailsverbose=False,
      
 
      
 
-)[source]
+)[source]
 
      Base Class for code wrappers
      
 
      
 
 
      
 
      
-class sympy.utilities.autowrap.CythonCodeWrapper(*args, **kwargs)[source]
      
+class sympy.utilities.autowrap.CythonCodeWrapper(*args, **kwargs)[source]
 
      Wrapper that uses Cython
      
 
      
 
      
-dump_pyx(routines, f, prefix)[source]
      
+dump_pyx(routines, f, prefix)[source]
 
      Write a Cython file with Python wrappers
      
 
      This file contains all the definitions of the routines in c code and
 refers to the header file.
      
@@ -976,19 +976,19 @@ 
      Implementation detailsverbose=False,
      
 
      
 
-)[source]
+)[source]
 
      Class used for testing independent of backends
      
 
      
 
 
      
 
      
-class sympy.utilities.autowrap.F2PyCodeWrapper(*args, **kwargs)[source]
      
+class sympy.utilities.autowrap.F2PyCodeWrapper(*args, **kwargs)[source]
 
      Wrapper that uses f2py
      
 
      
 
 
      
 
      
-class sympy.utilities.autowrap.UfuncifyCodeWrapper(*args, **kwargs)[source]
      
+class sympy.utilities.autowrap.UfuncifyCodeWrapper(*args, **kwargs)[source]
 
      Wrapper for Ufuncify
      
 
      
 
      
@@ -1001,7 +1001,7 @@ 
      Implementation detailsfuncname=None,
      
 
      
 
-)[source]
+)[source]
 
      Write a C file with Python wrappers
      
 
      This file contains all the definitions of the routines in c code.
      
 
      Arguments
      
@@ -1036,7 +1036,7 @@ 
      Implementation details**kwargs,
      
 
      
 
-)[source]
+)[source]
 
      Generates Python callable binaries based on the math expression.
      
 
      
 
      Parameters:
      
@@ -1131,7 +1131,7 @@ 
      Implementation details
 
      
-sympy.utilities.autowrap.binary_function(symfunc, expr, **kwargs)[source]
      
+sympy.utilities.autowrap.binary_function(symfunc, expr, **kwargs)[source]
 
      Returns a SymPy function with expr as binary implementation
      
 
      This is a convenience function that automates the steps needed to
 autowrap the SymPy expression and attaching it to a Function object
@@ -1183,7 +1183,7 @@ 
      Implementation details**kwargs,
      
 
      
 
-)[source]
+)[source]
 
      Generates a binary function that supports broadcasting on numpy arrays.
      
 
      
 
      Parameters:
      
diff --git a/dev/modules/utilities/codegen.html b/dev/modules/utilities/codegen.html
index 066ece2494e..e123fe7d84d 100644
--- a/dev/modules/utilities/codegen.html
+++ b/dev/modules/utilities/codegen.html
@@ -924,7 +924,7 @@ 
      Routine
      precision=None,
      
 
      
 
-)[source]
+)[source]
 
      An abstract Argument data structure: a name and a data type.
      
 
      This structure is refined in the descendants below.
      
 
      
@@ -940,7 +940,7 @@ 
      Routine
      cse=False,
      
 
      
 
-)[source]
+)[source]
 
      Generator for C code.
      
 
      The .write() method inherited from CodeGen will output a code file and
 an interface file, <prefix>.c and <prefix>.h respectively.
      
@@ -956,7 +956,7 @@ 
      Routine
      empty=True,
      
 
      
 
-)[source]
+)[source]
 
      Write the code by calling language specific methods.
      
 
      The generated file contains all the definitions of the routines in
 low-level code and refers to the header file if appropriate.
      
@@ -1001,7 +1001,7 @@ 
      Routine
      empty=True,
      
 
      
 
-)[source]
+)[source]
 
      Writes the C header file.
      
 
      This file contains all the function declarations.
      
 
      
@@ -1035,7 +1035,7 @@ 
      Routine
      
 
      
-get_prototype(routine)[source]
      
+get_prototype(routine)[source]
 
      Returns a string for the function prototype of the routine.
      
 
      If the routine has multiple result objects, an CodeGenError is
 raised.
      
@@ -1046,7 +1046,7 @@ 
      Routine
      
 
      
-class sympy.utilities.codegen.CodeGen(project='project', cse=False)[source]
      
+class sympy.utilities.codegen.CodeGen(project='project', cse=False)[source]
 
      Abstract class for the code generators.
      
 
      
 
      
@@ -1060,7 +1060,7 @@ 
      Routine
      empty=True,
      
 
      
 
-)[source]
+)[source]
 
      Write the code by calling language specific methods.
      
 
      The generated file contains all the definitions of the routines in
 low-level code and refers to the header file if appropriate.
      
@@ -1104,7 +1104,7 @@ 
      Routine
      global_vars=None,
      
 
      
 
-)[source]
+)[source]
 
      Creates an Routine object that is appropriate for this language.
      
 
      This implementation is appropriate for at least C/Fortran.  Subclasses
 can override this if necessary.
      
@@ -1128,7 +1128,7 @@ 
      Routine
      empty=True,
      
 
      
 
-)[source]
+)[source]
 
      Writes all the source code files for the given routines.
      
 
      The generated source is returned as a list of (filename, contents)
 tuples, or is written to files (see below).  Each filename consists
@@ -1177,13 +1177,13 @@ 
      Routine
      rsname,
      
 
      
 
-)[source]
+)[source]
 
      Holds strings for a certain datatype in different languages.
      
 
      
 
 
      
 
      
-class sympy.utilities.codegen.FCodeGen(project='project', printer=None)[source]
      
+class sympy.utilities.codegen.FCodeGen(project='project', printer=None)[source]
 
      Generator for Fortran 95 code
      
 
      The .write() method inherited from CodeGen will output a code file and
 an interface file, <prefix>.f90 and <prefix>.h respectively.
      
@@ -1199,7 +1199,7 @@ 
      Routine
      empty=True,
      
 
      
 
-)[source]
+)[source]
 
      Write the code by calling language specific methods.
      
 
      The generated file contains all the definitions of the routines in
 low-level code and refers to the header file if appropriate.
      
@@ -1244,7 +1244,7 @@ 
      Routine
      empty=True,
      
 
      
 
-)[source]
+)[source]
 
      Writes the interface to a header file.
      
 
      This file contains all the function declarations.
      
 
      
@@ -1277,7 +1277,7 @@ 
      Routine
      
 
      
-get_interface(routine)[source]
      
+get_interface(routine)[source]
 
      Returns a string for the function interface.
      
 
      The routine should have a single result object, which can be None.
 If the routine has multiple result objects, a CodeGenError is
@@ -1289,7 +1289,7 @@ 
      Routine
      
 
      
-class sympy.utilities.codegen.JuliaCodeGen(project='project', printer=None)[source]
      
+class sympy.utilities.codegen.JuliaCodeGen(project='project', printer=None)[source]
 
      Generator for Julia code.
      
 
      The .write() method inherited from CodeGen will output a code file
 <prefix>.jl.
      
@@ -1305,7 +1305,7 @@ 
      Routine
      empty=True,
      
 
      
 
-)[source]
+)[source]
 
      Write the code by calling language specific methods.
      
 
      The generated file contains all the definitions of the routines in
 low-level code and refers to the header file if appropriate.
      
@@ -1349,7 +1349,7 @@ 
      Routine
      global_vars,
      
 
      
 
-)[source]
+)[source]
 
      Specialized Routine creation for Julia.
      
 
      
 
@@ -1357,7 +1357,7 @@ 
      Routine
      
 
      
-class sympy.utilities.codegen.OctaveCodeGen(project='project', printer=None)[source]
      
+class sympy.utilities.codegen.OctaveCodeGen(project='project', printer=None)[source]
 
      Generator for Octave code.
      
 
      The .write() method inherited from CodeGen will output a code file
 <prefix>.m.
      
@@ -1380,7 +1380,7 @@ 
      Routine
      inline=True,
      
 
      
 
-)[source]
+)[source]
 
      Write the code by calling language specific methods.
      
 
      The generated file contains all the definitions of the routines in
 low-level code and refers to the header file if appropriate.
      
@@ -1424,7 +1424,7 @@ 
      Routine
      global_vars,
      
 
      
 
-)[source]
+)[source]
 
      Specialized Routine creation for Octave.
      
 
      
 
@@ -1443,7 +1443,7 @@ 
      Routine
      precision=None,
      
 
      
 
-)[source]
+)[source]
 
      OutputArgument are always initialized in the routine.
      
 
      
 
@@ -1460,7 +1460,7 @@ 
      Routine
      precision=None,
      
 
      
 
-)[source]
+)[source]
 
      An expression for a return value.
      
 
      The name result is used to avoid conflicts with the reserved word
 “return” in the Python language.  It is also shorter than ReturnValue.
      
@@ -1480,7 +1480,7 @@ 
      Routine
      global_vars,
      
 
      
 
-)[source]
+)[source]
 
      Generic description of evaluation routine for set of expressions.
      
 
      A CodeGen class can translate instances of this class into code in a
 particular language.  The routine specification covers all the features
@@ -1508,7 +1508,7 @@ 
      Routine
      
 
      
-class sympy.utilities.codegen.RustCodeGen(project='project', printer=None)[source]
      
+class sympy.utilities.codegen.RustCodeGen(project='project', printer=None)[source]
 
      Generator for Rust code.
      
 
      The .write() method inherited from CodeGen will output a code file
 <prefix>.rs
      
@@ -1524,7 +1524,7 @@ 
      Routine
      empty=True,
      
 
      
 
-)[source]
+)[source]
 
      Write the code by calling language specific methods.
      
 
      The generated file contains all the definitions of the routines in
 low-level code and refers to the header file if appropriate.
      
@@ -1559,7 +1559,7 @@ 
      Routine
      
 
      
-get_prototype(routine)[source]
      
+get_prototype(routine)[source]
 
      Returns a string for the function prototype of the routine.
      
 
      If the routine has multiple result objects, an CodeGenError is
 raised.
      
@@ -1577,7 +1577,7 @@ 
      Routine
      global_vars,
      
 
      
 
-)[source]
+)[source]
 
      Specialized Routine creation for Rust.
      
 
      
 
@@ -1602,7 +1602,7 @@ 
      Routine
      printer=None,
      
 
      
 
-)[source]
+)[source]
 
      Generate source code for expressions in a given language.
      
 
      
 
      Parameters:
      
@@ -1740,7 +1740,7 @@ 
      Routine
      
 
      
-sympy.utilities.codegen.get_default_datatype(expr, complex_allowed=None)[source]
      
+sympy.utilities.codegen.get_default_datatype(expr, complex_allowed=None)[source]
 
      Derives an appropriate datatype based on the expression.
      
 
      
 
@@ -1756,7 +1756,7 @@ 
      Routine
      language='F95',
      
 
      
 
-)[source]
+)[source]
 
      A factory that makes an appropriate Routine from an expression.
      
 
      
 
      Parameters:
      
diff --git a/dev/modules/utilities/decorator.html b/dev/modules/utilities/decorator.html
index 2589dcdcfca..b9c56ee65aa 100644
--- a/dev/modules/utilities/decorator.html
+++ b/dev/modules/utilities/decorator.html
@@ -813,7 +813,7 @@ 
      Documentation Version
      
 
      stacklevel=3,
      
 
      
 
-)[source]
+)[source]
 
      Mark a function as deprecated.
      
 
      This decorator should be used if an entire function or class is
 deprecated. If only a certain functionality is deprecated, you should use
@@ -869,7 +869,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.decorator.conserve_mpmath_dps(func)[source]
      
+sympy.utilities.decorator.conserve_mpmath_dps(func)[source]
 
      After the function finishes, resets the value of mpmath.mp.dps to
 the value it had before the function was run.
      
 
      
@@ -886,7 +886,7 @@ 
      Documentation Version
      
 
      ground_types=None,
      
 
      
 
-)[source]
+)[source]
 
      Adds metadata about the dependencies which need to be met for doctesting
 the docstrings of the decorated objects.
      
 
      exe should be a list of executables
      
@@ -898,7 +898,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.decorator.memoize_property(propfunc)[source]
      
+sympy.utilities.decorator.memoize_property(propfunc)[source]
 
      Property decorator that caches the value of potentially expensive
 propfunc after the first evaluation. The cached value is stored in
 the corresponding property name with an attached underscore.
      
@@ -906,7 +906,7 @@ 
      Documentation Version
      
 
 
      
 
      
-class sympy.utilities.decorator.no_attrs_in_subclass(cls, f)[source]
      
+class sympy.utilities.decorator.no_attrs_in_subclass(cls, f)[source]
 
      Don’t ‘inherit’ certain attributes from a base class
      
 
      >>> from sympy.utilities.decorator import no_attrs_in_subclass
 
      
@@ -932,7 +932,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.decorator.public(obj)[source]
      
+sympy.utilities.decorator.public(obj)[source]
 
      Append obj’s name to global __all__ variable (call site).
      
 
      By using this decorator on functions or classes you achieve the same goal
 as by filling __all__ variables manually, you just do not have to repeat
@@ -965,7 +965,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.decorator.threaded(func)[source]
      
+sympy.utilities.decorator.threaded(func)[source]
 
      Apply func to sub–elements of an object, including Add.
      
 
      This decorator is intended to make it uniformly possible to apply a
 function to all elements of composite objects, e.g. matrices, lists, tuples
@@ -982,13 +982,13 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.decorator.threaded_factory(func, use_add)[source]
      
+sympy.utilities.decorator.threaded_factory(func, use_add)[source]
 
      A factory for threaded decorators.
      
 
      
 
 
      
 
      
-sympy.utilities.decorator.xthreaded(func)[source]
      
+sympy.utilities.decorator.xthreaded(func)[source]
 
      Apply func to sub–elements of an object, excluding Add.
      
 
      This decorator is intended to make it uniformly possible to apply a
 function to all elements of composite objects, e.g. matrices, lists, tuples
diff --git a/dev/modules/utilities/enumerative.html b/dev/modules/utilities/enumerative.html
index 88c88895e3f..a758ffd160a 100644
--- a/dev/modules/utilities/enumerative.html
+++ b/dev/modules/utilities/enumerative.html
@@ -804,7 +804,7 @@ 
      Documentation Version
      
 counting multiset partitions.
      
 
      
 
      
-sympy.utilities.enumerative.multiset_partitions_taocp(multiplicities)[source]
      
+sympy.utilities.enumerative.multiset_partitions_taocp(multiplicities)[source]
 
      Enumerates partitions of a multiset.
      
 
      
 
      Parameters:
      
@@ -867,7 +867,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.enumerative.factoring_visitor(state, primes)[source]
      
+sympy.utilities.enumerative.factoring_visitor(state, primes)[source]
 
      Use with multiset_partitions_taocp to enumerate the ways a
 number can be expressed as a product of factors.  For this usage,
 the exponents of the prime factors of a number are arguments to
@@ -894,7 +894,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.enumerative.list_visitor(state, components)[source]
      
+sympy.utilities.enumerative.list_visitor(state, components)[source]
 
      Return a list of lists to represent the partition.
      
 
      Examples
      
 
      >>> from sympy.utilities.enumerative import list_visitor
@@ -914,7 +914,7 @@ 
      Documentation Version
      
 and generalized by the class MultisetPartitionTraverser.
      
 
      
 
      
-class sympy.utilities.enumerative.MultisetPartitionTraverser[source]
      
+class sympy.utilities.enumerative.MultisetPartitionTraverser[source]
 
      Has methods to enumerate and count the partitions of a multiset.
      
 
      This implements a refactored and extended version of Knuth’s algorithm
 7.1.2.5M [AOCP].”
      
@@ -964,7 +964,7 @@ 
      Documentation Version
      
 
      multiplicities,
      
 
      
 
-)[source]
+)[source]
 
      Returns the number of partitions of a multiset whose components
 have the multiplicities given in multiplicities.
      
 
      For larger counts, this method is much faster than calling one
@@ -1035,7 +1035,7 @@ 
      Documentation Version
      
 
      multiplicities,
      
 
      
 
-)[source]
+)[source]
 
      Enumerate the partitions of a multiset.
      
 
      Examples
      
 
      >>> from sympy.utilities.enumerative import list_visitor
@@ -1072,7 +1072,7 @@ 
      Documentation Version
      
 
      lb,
      
 
      
 
-)[source]
+)[source]
 
      Enumerate the partitions of a multiset with lb < num(parts)
      
 
      Equivalent to enum_range(multiplicities, lb, sum(multiplicities))
      
 
      
@@ -1116,7 +1116,7 @@ 
      Documentation Version
      
 
      ub,
      
 
      
 
-)[source]
+)[source]
 
      Enumerate the partitions of a multiset with
 lb < num(parts) <= ub.
      
 
      In particular, if partitions with exactly k parts are
@@ -1145,7 +1145,7 @@ 
      Documentation Version
      
 
      ub,
      
 
      
 
-)[source]
+)[source]
 
      Enumerate multiset partitions with no more than ub parts.
      
 
      Equivalent to enum_range(multiplicities, 0, ub)
      
 
      
diff --git a/dev/modules/utilities/exceptions.html b/dev/modules/utilities/exceptions.html
index e4436be3fe1..aada3164e40 100644
--- a/dev/modules/utilities/exceptions.html
+++ b/dev/modules/utilities/exceptions.html
@@ -812,7 +812,7 @@ 
      Documentation Version
      
 
      active_deprecations_target,
      
 
      
 
-)[source]
+)[source]
 
      A warning for deprecated features of SymPy.
      
 
      See the Deprecation Policy document for details on when and how
 things should be deprecated in SymPy.
      
@@ -843,7 +843,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.exceptions.ignore_warnings(warningcls)[source]
      
+sympy.utilities.exceptions.ignore_warnings(warningcls)[source]
 
      Context manager to suppress warnings during tests.
      
 
      
 
      Note
      
@@ -898,7 +898,7 @@ 
      Documentation Version
      
 
      stacklevel=3,
      
 
      
 
-)[source]
+)[source]
 
      Warn that a feature is deprecated in SymPy.
      
 
      See the Deprecation Policy document for details on when and how
 things should be deprecated in SymPy.
      
diff --git a/dev/modules/utilities/iterables.html b/dev/modules/utilities/iterables.html
index 58f58aac8bf..708fb249e0c 100644
--- a/dev/modules/utilities/iterables.html
+++ b/dev/modules/utilities/iterables.html
@@ -802,7 +802,7 @@ 
      Documentation Version
      
 
      Iterables
      
 
      
 
      
-class sympy.utilities.iterables.NotIterable[source]
      
+class sympy.utilities.iterables.NotIterable[source]
 
      Use this as mixin when creating a class which is not supposed to
 return true when iterable() is called on its instances because
 calling list() on the instance, for example, would result in
@@ -811,7 +811,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.binary_partitions(n)[source]
      
+sympy.utilities.iterables.binary_partitions(n)[source]
 
      Generates the binary partition of n.
      
 
      A binary partition consists only of numbers that are
 powers of two. Each step reduces a \(2^{k+1}\) to \(2^k\) and
@@ -838,13 +838,13 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.bracelets(n, k)[source]
      
+sympy.utilities.iterables.bracelets(n, k)[source]
 
      Wrapper to necklaces to return a free (unrestricted) necklace.
      
 
      
 
 
      
 
      
-sympy.utilities.iterables.capture(func)[source]
      
+sympy.utilities.iterables.capture(func)[source]
 
      Return the printed output of func().
      
 
      func should be a function without arguments that produces output with
 print statements.
      
@@ -864,7 +864,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.common_prefix(*seqs)[source]
      
+sympy.utilities.iterables.common_prefix(*seqs)[source]
 
      Return the subsequence that is a common start of sequences in seqs.
      
 
      >>> from sympy.utilities.iterables import common_prefix
 >>> common_prefix(list(range(3)))
@@ -881,7 +881,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.common_suffix(*seqs)[source]
      
+sympy.utilities.iterables.common_suffix(*seqs)[source]
 
      Return the subsequence that is a common ending of sequences in seqs.
      
 
      >>> from sympy.utilities.iterables import common_suffix
 >>> common_suffix(list(range(3)))
@@ -898,7 +898,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.connected_components(G)[source]
      
+sympy.utilities.iterables.connected_components(G)[source]
 
      Connected components of an undirected graph or weakly connected components
 of a directed graph.
      
 
      
@@ -959,13 +959,13 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.dict_merge(*dicts)[source]
      
+sympy.utilities.iterables.dict_merge(*dicts)[source]
 
      Merge dictionaries into a single dictionary.
      
 
      
 
 
      
 
      
-sympy.utilities.iterables.filter_symbols(iterator, exclude)[source]
      
+sympy.utilities.iterables.filter_symbols(iterator, exclude)[source]
 
      Only yield elements from \(iterator\) that do not occur in \(exclude\).
      
 
      
 
      Parameters:
      
@@ -989,7 +989,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.flatten(iterable, levels=None, cls=None)[source]
      
+sympy.utilities.iterables.flatten(iterable, levels=None, cls=None)[source]
 
      Recursively denest iterable containers.
      
 
      >>> from sympy import flatten
 
      
@@ -1029,7 +1029,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.generate_bell(n)[source]
      
+sympy.utilities.iterables.generate_bell(n)[source]
 
      Return permutations of [0, 1, …, n - 1] such that each permutation
 differs from the last by the exchange of a single pair of neighbors.
 The n! permutations are returned as an iterator. In order to obtain
@@ -1103,7 +1103,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.generate_derangements(s)[source]
      
+sympy.utilities.iterables.generate_derangements(s)[source]
 
      Return unique derangements of the elements of iterable s.
      
 
      Examples
      
 
      >>> from sympy.utilities.iterables import generate_derangements
@@ -1123,7 +1123,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.generate_involutions(n)[source]
      
+sympy.utilities.iterables.generate_involutions(n)[source]
 
      Generates involutions.
      
 
      An involution is a permutation that when multiplied
 by itself equals the identity permutation. In this
@@ -1151,7 +1151,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.generate_oriented_forest(n)[source]
      
+sympy.utilities.iterables.generate_oriented_forest(n)[source]
 
      This algorithm generates oriented forests.
      
 
      An oriented graph is a directed graph having no symmetric pair of directed
 edges. A forest is an acyclic graph, i.e., it has no cycles. A forest can
@@ -1179,7 +1179,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.group(seq, multiple=True)[source]
      
+sympy.utilities.iterables.group(seq, multiple=True)[source]
 
      Splits a sequence into a list of lists of equal, adjacent elements.
      
 
      Examples
      
 
      >>> from sympy import group
@@ -1201,7 +1201,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.has_dups(seq)[source]
      
+sympy.utilities.iterables.has_dups(seq)[source]
 
      Return True if there are any duplicate elements in seq.
      
 
      Examples
      
 
      >>> from sympy import has_dups, Dict, Set
@@ -1217,7 +1217,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.has_variety(seq)[source]
      
+sympy.utilities.iterables.has_variety(seq)[source]
 
      Return True if there are any different elements in seq.
      
 
      Examples
      
 
      >>> from sympy import has_variety
@@ -1233,7 +1233,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.ibin(n, bits=None, str=False)[source]
      
+sympy.utilities.iterables.ibin(n, bits=None, str=False)[source]
 
      Return a list of length bits corresponding to the binary value
 of n with small bits to the right (last). If bits is omitted, the
 length will be the number required to represent n. If the bits are
@@ -1276,7 +1276,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.iproduct(*iterables)[source]
      
+sympy.utilities.iterables.iproduct(*iterables)[source]
 
      Cartesian product of iterables.
      
 
      Generator of the Cartesian product of iterables. This is analogous to
 itertools.product except that it works with infinite iterables and will
@@ -1303,7 +1303,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.is_palindromic(s, i=0, j=None)[source]
      
+sympy.utilities.iterables.is_palindromic(s, i=0, j=None)[source]
 
      Return True if the sequence is the same from left to right as it
 is from right to left in the whole sequence (default) or in the
 Python slice s[i: j]; else False.
      
@@ -1336,7 +1336,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.is_sequence(i, include=None)[source]
      
+sympy.utilities.iterables.is_sequence(i, include=None)[source]
 
      Return a boolean indicating whether i is a sequence in the SymPy
 sense. If anything that fails the test below should be included as
 being a sequence for your application, set ‘include’ to that object’s
@@ -1377,7 +1377,7 @@ 
      Documentation Version
      
 
      <class 'sympy.utilities.iterables.NotIterable'>),
      
 
      
 
-)[source]
+)[source]
 
      Return a boolean indicating whether i is SymPy iterable.
 True also indicates that the iterator is finite, e.g. you can
 call list(…) on the instance.
      
@@ -1421,7 +1421,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.kbins(l, k, ordered=None)[source]
      
+sympy.utilities.iterables.kbins(l, k, ordered=None)[source]
 
      Return sequence l partitioned into k bins.
      
 
      Examples
      
 
      The default is to give the items in the same order, but grouped
@@ -1501,7 +1501,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.least_rotation(x, key=None)[source]
      
+sympy.utilities.iterables.least_rotation(x, key=None)[source]
 
      Returns the number of steps of left rotation required to
 obtain lexicographically minimal string/list/tuple, etc.
      
 
      Examples
      
@@ -1524,7 +1524,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.minlex(seq, directed=True, key=None)[source]
      
+sympy.utilities.iterables.minlex(seq, directed=True, key=None)[source]
 
      Return the rotation of the sequence in which the lexically smallest
 elements appear first, e.g. \(cba \rightarrow acb\).
      
 
      The sequence returned is a tuple, unless the input sequence is a string
@@ -1558,7 +1558,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.multiset(seq)[source]
      
+sympy.utilities.iterables.multiset(seq)[source]
 
      Return the hashable sequence in multiset form with values being the
 multiplicity of the item in the sequence.
      
 
      Examples
      
@@ -1575,7 +1575,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.multiset_combinations(m, n, g=None)[source]
      
+sympy.utilities.iterables.multiset_combinations(m, n, g=None)[source]
 
      Return the unique combinations of size n from multiset m.
      
 
      Examples
      
 
      >>> from sympy.utilities.iterables import multiset_combinations
@@ -1602,7 +1602,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.multiset_derangements(s)[source]
      
+sympy.utilities.iterables.multiset_derangements(s)[source]
 
      Generate derangements of the elements of s in place.
      
 
      Examples
      
 
      >>> from sympy.utilities.iterables import multiset_derangements, uniq
@@ -1623,7 +1623,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.multiset_partitions(multiset, m=None)[source]
      
+sympy.utilities.iterables.multiset_partitions(multiset, m=None)[source]
 
      Return unique partitions of the given multiset (in list form).
 If m is None, all multisets will be returned, otherwise only
 partitions with m parts will be returned.
      
@@ -1687,7 +1687,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.multiset_permutations(m, size=None, g=None)[source]
      
+sympy.utilities.iterables.multiset_permutations(m, size=None, g=None)[source]
 
      Return the unique permutations of multiset m.
      
 
      Examples
      
 
      >>> from sympy.utilities.iterables import multiset_permutations
@@ -1704,7 +1704,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.necklaces(n, k, free=False)[source]
      
+sympy.utilities.iterables.necklaces(n, k, free=False)[source]
 
      A routine to generate necklaces that may (free=True) or may not
 (free=False) be turned over to be viewed. The “necklaces” returned
 are comprised of n integers (beads) with k different
@@ -1765,7 +1765,7 @@ 
      Documentation Version
      
 
      **assumptions,
      
 
      
 
-)[source]
+)[source]
 
      Generate an infinite stream of Symbols consisting of a prefix and
 increasing subscripts provided that they do not occur in exclude.
      
 
      
@@ -1804,7 +1804,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.ordered_partitions(n, m=None, sort=True)[source]
      
+sympy.utilities.iterables.ordered_partitions(n, m=None, sort=True)[source]
 
      Generates ordered partitions of integer n.
      
 
      
 
      Parameters:
      
@@ -1894,7 +1894,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.partitions(n, m=None, k=None, size=False)[source]
      
+sympy.utilities.iterables.partitions(n, m=None, k=None, size=False)[source]
 
      Generate all partitions of positive integer, n.
      
 
      Each partition is represented as a dictionary, mapping an integer
 to the number of copies of that integer in the partition.  For example,
@@ -1960,7 +1960,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.permute_signs(t)[source]
      
+sympy.utilities.iterables.permute_signs(t)[source]
 
      Return iterator in which the signs of non-zero elements
 of t are permuted.
      
 
      Examples
      
@@ -1973,7 +1973,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.postfixes(seq)[source]
      
+sympy.utilities.iterables.postfixes(seq)[source]
 
      Generate all postfixes of a sequence.
      
 
      Examples
      
 
      >>> from sympy.utilities.iterables import postfixes
@@ -1987,7 +1987,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.prefixes(seq)[source]
      
+sympy.utilities.iterables.prefixes(seq)[source]
 
      Generate all prefixes of a sequence.
      
 
      Examples
      
 
      >>> from sympy.utilities.iterables import prefixes
@@ -2001,7 +2001,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.random_derangement(t, choice=None, strict=True)[source]
      
+sympy.utilities.iterables.random_derangement(t, choice=None, strict=True)[source]
 
      Return a list of elements in which none are in the same positions
 as they were originally. If an element fills more than half of the positions
 then an error will be raised since no derangement is possible. To obtain
@@ -2035,7 +2035,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.reshape(seq, how)[source]
      
+sympy.utilities.iterables.reshape(seq, how)[source]
 
      Reshape the sequence according to the template in how.
      
 
      Examples
      
 
      >>> from sympy.utilities import reshape
@@ -2082,7 +2082,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.rotate_left(x, y)[source]
      
+sympy.utilities.iterables.rotate_left(x, y)[source]
 
      Left rotates a list x by the number of steps specified
 in y.
      
 
      Examples
      
@@ -2096,7 +2096,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.rotate_right(x, y)[source]
      
+sympy.utilities.iterables.rotate_right(x, y)[source]
 
      Right rotates a list x by the number of steps specified
 in y.
      
 
      Examples
      
@@ -2110,7 +2110,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.rotations(s, dir=1)[source]
      
+sympy.utilities.iterables.rotations(s, dir=1)[source]
 
      Return a generator giving the items in s as list where
 each subsequent list has the items rotated to the left (default)
 or right (dir=-1) relative to the previous list.
      
@@ -2126,7 +2126,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.roundrobin(*iterables)[source]
      
+sympy.utilities.iterables.roundrobin(*iterables)[source]
 
      roundrobin recipe taken from itertools documentation:
 https://docs.python.org/3/library/itertools.html#itertools-recipes
      
 
      roundrobin(‘ABC’, ‘D’, ‘EF’) –> A D E B F C
      
@@ -2135,7 +2135,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.runs(seq, op=<built-in function gt>)[source]
      
+sympy.utilities.iterables.runs(seq, op=<built-in function gt>)[source]
 
      Group the sequence into lists in which successive elements
 all compare the same with the comparison operator, op:
 op(seq[i + 1], seq[i]) is True from all elements in a run.
      
@@ -2152,7 +2152,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.sequence_partitions(l, n, /)[source]
      
+sympy.utilities.iterables.sequence_partitions(l, n, /)[source]
 
      Returns the partition of sequence \(l\) into \(n\) bins
      
 
      
 
      Parameters:
      
@@ -2202,7 +2202,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.sequence_partitions_empty(l, n, /)[source]
      
+sympy.utilities.iterables.sequence_partitions_empty(l, n, /)[source]
 
      Returns the partition of sequence \(l\) into \(n\) bins with
 empty sequence
      
 
      
@@ -2255,7 +2255,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.sift(seq, keyfunc, binary=False)[source]
      
+sympy.utilities.iterables.sift(seq, keyfunc, binary=False)[source]
 
      Sift the sequence, seq according to keyfunc.
      
 
      
 
      Returns:
      
@@ -2327,7 +2327,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.signed_permutations(t)[source]
      
+sympy.utilities.iterables.signed_permutations(t)[source]
 
      Return iterator in which the signs of non-zero elements
 of t and the order of the elements are permuted and all
 returned values are unique.
      
@@ -2345,7 +2345,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.strongly_connected_components(G)[source]
      
+sympy.utilities.iterables.strongly_connected_components(G)[source]
 
      Strongly connected components of a directed graph in reverse topological
 order.
      
 
      
@@ -2419,7 +2419,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.subsets(seq, k=None, repetition=False)[source]
      
+sympy.utilities.iterables.subsets(seq, k=None, repetition=False)[source]
 
      Generates all \(k\)-subsets (combinations) from an \(n\)-element set, seq.
      
 
      A \(k\)-subset of an \(n\)-element set is any subset of length exactly \(k\). The
 number of \(k\)-subsets of an \(n\)-element set is given by binomial(n, k),
@@ -2460,13 +2460,13 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.take(iter, n)[source]
      
+sympy.utilities.iterables.take(iter, n)[source]
 
      Return n items from iter iterator.
      
 
      
 
 
      
 
      
-sympy.utilities.iterables.topological_sort(graph, key=None)[source]
      
+sympy.utilities.iterables.topological_sort(graph, key=None)[source]
 
      Topological sort of graph’s vertices.
      
 
      
 
      Parameters:
      
@@ -2541,14 +2541,14 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.unflatten(iter, n=2)[source]
      
+sympy.utilities.iterables.unflatten(iter, n=2)[source]
 
      Group iter into tuples of length n. Raise an error if
 the length of iter is not a multiple of n.
      
 
      
 
 
      
 
      
-sympy.utilities.iterables.uniq(seq, result=None)[source]
      
+sympy.utilities.iterables.uniq(seq, result=None)[source]
 
      Yield unique elements from seq as an iterator. The second
 parameter result  is used internally; it is not necessary
 to pass anything for this.
      
@@ -2575,7 +2575,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.iterables.variations(seq, n, repetition=False)[source]
      
+sympy.utilities.iterables.variations(seq, n, repetition=False)[source]
 
      Returns an iterator over the n-sized variations of seq (size N).
 repetition controls whether items in seq can appear more than once;
      
 
      Examples
      
diff --git a/dev/modules/utilities/lambdify.html b/dev/modules/utilities/lambdify.html
index 543446710e1..0f7ea765efa 100644
--- a/dev/modules/utilities/lambdify.html
+++ b/dev/modules/utilities/lambdify.html
@@ -804,7 +804,7 @@ 
      Documentation Version
      
 lambda functions which can be used to calculate numerical values very fast.
      
 
      
 
      
-sympy.utilities.lambdify.implemented_function(symfunc, implementation)[source]
      
+sympy.utilities.lambdify.implemented_function(symfunc, implementation)[source]
 
      Add numerical implementation to function symfunc.
      
 
      symfunc can be an UndefinedFunction instance, or a name string.
 In the latter case we create an UndefinedFunction instance with that
@@ -847,7 +847,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.lambdify.lambdastr(args, expr, printer=None, dummify=None)[source]
      
+sympy.utilities.lambdify.lambdastr(args, expr, printer=None, dummify=None)[source]
 
      Returns a string that can be evaluated to a lambda function.
      
 
      Examples
      
 
      >>> from sympy.abc import x, y, z
@@ -882,7 +882,7 @@ 
      Documentation Version
      
 
      docstring_limit=1000,
      
 
      
 
-)[source]
+)[source]
 
      Convert a SymPy expression into a function that allows for fast
 numeric evaluation.
      
 
      
diff --git a/dev/modules/utilities/memoization.html b/dev/modules/utilities/memoization.html
index f8d6320e96e..45c99d2b8d0 100644
--- a/dev/modules/utilities/memoization.html
+++ b/dev/modules/utilities/memoization.html
@@ -802,7 +802,7 @@ 
      Documentation Version
      
 
      Memoization
      
 
      
 
      
-sympy.utilities.memoization.assoc_recurrence_memo(base_seq)[source]
      
+sympy.utilities.memoization.assoc_recurrence_memo(base_seq)[source]
 
      Memo decorator for associated sequences defined by recurrence starting from base
      
 
      base_seq(n) – callable to get base sequence elements
      
 
      XXX works only for Pn0 = base_seq(0) cases
@@ -811,7 +811,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.memoization.recurrence_memo(initial)[source]
      
+sympy.utilities.memoization.recurrence_memo(initial)[source]
 
      Memo decorator for sequences defined by recurrence
      
 
      Examples
      
 
      >>> from sympy.utilities.memoization import recurrence_memo
diff --git a/dev/modules/utilities/misc.html b/dev/modules/utilities/misc.html
index 2102328e0fa..e861c0206c8 100644
--- a/dev/modules/utilities/misc.html
+++ b/dev/modules/utilities/misc.html
@@ -803,7 +803,7 @@ 
      Documentation Version
      
 
      Miscellaneous stuff that does not really fit anywhere else.
      
 
      
 
      
-sympy.utilities.misc.as_int(n, strict=True)[source]
      
+sympy.utilities.misc.as_int(n, strict=True)[source]
 
      Convert the argument to a builtin integer.
      
 
      The return value is guaranteed to be equal to the input. ValueError is
 raised if the input has a non-integral value. When strict is True, this
@@ -852,27 +852,27 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.misc.debug(*args)[source]
      
+sympy.utilities.misc.debug(*args)[source]
 
      Print *args if SYMPY_DEBUG is True, else do nothing.
      
 
      
 
 
      
 
      
-sympy.utilities.misc.debug_decorator(func)[source]
      
+sympy.utilities.misc.debug_decorator(func)[source]
 
      If SYMPY_DEBUG is True, it will print a nice execution tree with
 arguments and results of all decorated functions, else do nothing.
      
 
      
 
 
      
 
      
-sympy.utilities.misc.debugf(string, args)[source]
      
+sympy.utilities.misc.debugf(string, args)[source]
 
      Print string%args if SYMPY_DEBUG is True, else do nothing. This is
 intended for debug messages using formatted strings.
      
 
      
 
 
      
 
      
-sympy.utilities.misc.filldedent(s, w=70, **kwargs)[source]
      
+sympy.utilities.misc.filldedent(s, w=70, **kwargs)[source]
 
      Strips leading and trailing empty lines from a copy of s, then dedents,
 fills and returns it.
      
 
      Empty line stripping serves to deal with docstrings like this one that
@@ -887,7 +887,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.misc.find_executable(executable, path=None)[source]
      
+sympy.utilities.misc.find_executable(executable, path=None)[source]
 
      Try to find ‘executable’ in the directories listed in ‘path’ (a
 string listing directories separated by ‘os.pathsep’; defaults to
 os.environ[‘PATH’]).  Returns the complete filename or None if not
@@ -896,7 +896,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.misc.func_name(x, short=False)[source]
      
+sympy.utilities.misc.func_name(x, short=False)[source]
 
      Return function name of \(x\) (if defined) else the \(type(x)\).
 If short is True and there is a shorter alias for the result,
 return the alias.
      
@@ -916,13 +916,13 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.misc.ordinal(num)[source]
      
+sympy.utilities.misc.ordinal(num)[source]
 
      Return ordinal number string of num, e.g. 1 becomes 1st.
      
 
      
 
 
      
 
      
-sympy.utilities.misc.rawlines(s)[source]
      
+sympy.utilities.misc.rawlines(s)[source]
 
      Return a cut-and-pastable string that, when printed, is equivalent
 to the input. Use this when there is more than one line in the
 string. The string returned is formatted so it can be indented
@@ -986,7 +986,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.misc.replace(string, *reps)[source]
      
+sympy.utilities.misc.replace(string, *reps)[source]
 
      Return string with all keys in reps replaced with
 their corresponding values, longer strings first, irrespective
 of the order they are given.  reps may be passed as tuples
@@ -1021,7 +1021,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.misc.strlines(s, c=64, short=False)[source]
      
+sympy.utilities.misc.strlines(s, c=64, short=False)[source]
 
      Return a cut-and-pastable string that, when printed, is
 equivalent to the input.  The lines will be surrounded by
 parentheses and no line will be longer than c (default 64)
@@ -1052,7 +1052,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.misc.translate(s, a, b=None, c=None)[source]
      
+sympy.utilities.misc.translate(s, a, b=None, c=None)[source]
 
      Return s where characters have been replaced or deleted.
      
 
      Syntax
      
 
      
diff --git a/dev/modules/utilities/source.html b/dev/modules/utilities/source.html
index d4e90c0e4b0..c33cf028a1e 100644
--- a/dev/modules/utilities/source.html
+++ b/dev/modules/utilities/source.html
@@ -803,7 +803,7 @@ 
      Documentation Version
      
 
      This module adds several functions for interactive source code inspection.
      
 
      
 
      
-sympy.utilities.source.get_class(lookup_view)[source]
      
+sympy.utilities.source.get_class(lookup_view)[source]
 
      Convert a string version of a class name to the object.
      
 
      For example, get_class(‘sympy.core.Basic’) will return
 class Basic located in module sympy.core
      
@@ -811,7 +811,7 @@ 
      Documentation Version
      
 
 
      
 
      
-sympy.utilities.source.get_mod_func(callback)[source]
      
+sympy.utilities.source.get_mod_func(callback)[source]
 
      splits the string path to a class into a string path to the module
 and the name of the class.
      
 
      Examples
      
diff --git a/dev/modules/utilities/timeutils.html b/dev/modules/utilities/timeutils.html
index c628a44092e..f2c41c636b1 100644
--- a/dev/modules/utilities/timeutils.html
+++ b/dev/modules/utilities/timeutils.html
@@ -803,7 +803,7 @@ 
      Documentation Version
      
 
      Simple tools for timing functions’ execution, when IPython is not available.
      
 
      
 
      
-sympy.utilities.timeutils.timed(func, setup='pass', limit=None)[source]
      
+sympy.utilities.timeutils.timed(func, setup='pass', limit=None)[source]
 
      Adaptively measure execution time of a function.
      
 
      
 
diff --git a/dev/modules/vector/api/classes.html b/dev/modules/vector/api/classes.html
index 2e7c7f19e4c..1eebf8c7231 100644
--- a/dev/modules/vector/api/classes.html
+++ b/dev/modules/vector/api/classes.html
@@ -814,7 +814,7 @@ 
      Essential Classes in sympy.vector (docstrings)variable_names=None,
      
 
      
 
-)[source]
+)[source]
 
      Represents a coordinate system in 3-D space.
      
 
      
 
      
@@ -834,7 +834,7 @@ 
      Essential Classes in sympy.vector (docstrings)transformation=None,
      
 
      
 
-)[source]
+)[source]
 
      The orientation/location parameters are necessary if this system
 is being defined at a certain orientation or location wrt another.
      
 
      
@@ -885,7 +885,7 @@ 
      Essential Classes in sympy.vector (docstrings)vector_names=None,
      
 
      
 
-)[source]
+)[source]
 
      Returns a CoordSys3D which is connected to self by transformation.
      
 
      
 
      Parameters:
      
@@ -929,7 +929,7 @@ 
      Essential Classes in sympy.vector (docstrings)variable_names=None,
      
 
      
 
-)[source]
+)[source]
 
      Returns a CoordSys3D with its origin located at the given
 position wrt this coordinate system’s origin.
      
 
      
@@ -973,7 +973,7 @@ 
      Essential Classes in sympy.vector (docstrings)variable_names=None,
      
 
      
 
-)[source]
+)[source]
 
      Creates a new CoordSys3D oriented in the user-specified way
 with respect to this system.
      
 
      Please refer to the documentation of the orienter classes
@@ -1053,7 +1053,7 @@ 
      Essential Classes in sympy.vector (docstrings)variable_names=None,
      
 
      
 
-)[source]
+)[source]
 
      Axis rotation is a rotation about an arbitrary axis by
 some angle. The angle is supplied as a SymPy expr scalar, and
 the axis is supplied as a Vector.
      
@@ -1110,7 +1110,7 @@ 
      Essential Classes in sympy.vector (docstrings)variable_names=None,
      
 
      
 
-)[source]
+)[source]
 
      Body orientation takes this coordinate system through three
 successive simple rotations.
      
 
      Body fixed rotations include both Euler Angles and
@@ -1190,7 +1190,7 @@ 
      Essential Classes in sympy.vector (docstrings)variable_names=None,
      
 
      
 
-)[source]
+)[source]
 
      Quaternion orientation orients the new CoordSys3D with
 Quaternions, defined as a finite rotation about lambda, a unit
 vector, by some amount theta.
      
@@ -1249,7 +1249,7 @@ 
      Essential Classes in sympy.vector (docstrings)variable_names=None,
      
 
      
 
-)[source]
+)[source]
 
      Space rotation is similar to Body rotation, but the rotations
 are applied in the opposite order.
      
 
      
@@ -1312,7 +1312,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-position_wrt(other)[source]
      
+position_wrt(other)[source]
 
      Returns the position vector of the origin of this coordinate
 system with respect to another Point/CoordSys3D.
      
 
      
@@ -1337,7 +1337,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-rotation_matrix(other)[source]
      
+rotation_matrix(other)[source]
 
      Returns the direction cosine matrix(DCM), also known as the
 ‘rotation matrix’ of this coordinate system with respect to
 another system.
      
@@ -1370,7 +1370,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-scalar_map(other)[source]
      
+scalar_map(other)[source]
 
      Returns a dictionary which expresses the coordinate variables
 (base scalars) of this frame in terms of the variables of
 otherframe.
      
@@ -1398,7 +1398,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-class sympy.vector.vector.Vector(*args)[source]
      
+class sympy.vector.vector.Vector(*args)[source]
 
      Super class for all Vector classes.
 Ideally, neither this class nor any of its subclasses should be
 instantiated by the user.
      
@@ -1420,7 +1420,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-cross(other)[source]
      
+cross(other)[source]
 
      Returns the cross product of this Vector with another Vector or
 Dyadic instance.
 The cross product is a Vector, if ‘other’ is a Vector. If ‘other’
@@ -1452,7 +1452,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-dot(other)[source]
      
+dot(other)[source]
 
      Returns the dot product of this Vector, either with another
 Vector, or a Dyadic, or a Del operator.
 If ‘other’ is a Vector, returns the dot product scalar (SymPy
@@ -1492,19 +1492,19 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-magnitude()[source]
      
+magnitude()[source]
 
      Returns the magnitude of this vector.
      
 
      
 
 
      
 
      
-normalize()[source]
      
+normalize()[source]
 
      Returns the normalized version of this vector.
      
 
      
 
 
      
 
      
-outer(other)[source]
      
+outer(other)[source]
 
      Returns the outer product of this vector with another, in the
 form of a Dyadic instance.
      
 
      
@@ -1527,7 +1527,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-projection(other, scalar=False)[source]
      
+projection(other, scalar=False)[source]
 
      Returns the vector or scalar projection of the ‘other’ on ‘self’.
      
 
      Examples
      
 
      >>> from sympy.vector.coordsysrect import CoordSys3D
@@ -1545,7 +1545,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-separate()[source]
      
+separate()[source]
 
      The constituents of this vector in different coordinate systems,
 as per its definition.
      
 
      Returns a dict mapping each CoordSys3D to the corresponding
@@ -1563,7 +1563,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-to_matrix(system)[source]
      
+to_matrix(system)[source]
 
      Returns the matrix form of this vector with respect to the
 specified coordinate system.
      
 
      
@@ -1592,7 +1592,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-class sympy.vector.dyadic.Dyadic(*args)[source]
      
+class sympy.vector.dyadic.Dyadic(*args)[source]
 
      Super class for all Dyadic-classes.
      
 
      References
      
 
      
@@ -1616,7 +1616,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-cross(other)[source]
      
+cross(other)[source]
 
      Returns the cross product between this Dyadic, and a Vector, as a
 Vector instance.
      
 
      
@@ -1639,7 +1639,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-dot(other)[source]
      
+dot(other)[source]
 
      Returns the dot product(also called inner product) of this
 Dyadic, with another Dyadic or Vector.
 If ‘other’ is a Dyadic, this returns a Dyadic. Else, it returns
@@ -1667,7 +1667,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-to_matrix(system, second_system=None)[source]
      
+to_matrix(system, second_system=None)[source]
 
      Returns the matrix form of the dyadic with respect to one or two
 coordinate systems.
      
 
      
@@ -1711,12 +1711,12 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-class sympy.vector.deloperator.Del[source]
      
+class sympy.vector.deloperator.Del[source]
 
      Represents the vector differential operator, usually represented in
 mathematical expressions as the ‘nabla’ symbol.
      
 
      
 
      
-cross(vect, doit=False)[source]
      
+cross(vect, doit=False)[source]
 
      Represents the cross product between this operator and a given
 vector - equal to the curl of the vector field.
      
 
      
@@ -1749,7 +1749,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-dot(vect, doit=False)[source]
      
+dot(vect, doit=False)[source]
 
      Represents the dot product between this operator and a given
 vector - equal to the divergence of the vector field.
      
 
      
@@ -1781,7 +1781,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-gradient(scalar_field, doit=False)[source]
      
+gradient(scalar_field, doit=False)[source]
 
      Returns the gradient of the given scalar field, as a
 Vector instance.
      
 
      
@@ -1814,7 +1814,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-class sympy.vector.parametricregion.ParametricRegion(definition, *bounds)[source]
      
+class sympy.vector.parametricregion.ParametricRegion(definition, *bounds)[source]
 
      Represents a parametric region in space.
      
 
      
 
      Parameters:
      
@@ -1857,7 +1857,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-class sympy.vector.implicitregion.ImplicitRegion(variables, equation)[source]
      
+class sympy.vector.implicitregion.ImplicitRegion(variables, equation)[source]
 
      Represents an implicit region in space.
      
 
      
 
      Parameters:
      
@@ -1897,7 +1897,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-multiplicity(point)[source]
      
+multiplicity(point)[source]
 
      Returns the multiplicity of a singular point on the region.
      
 
      A singular point (x,y) of region is said to be of multiplicity m
 if all the partial derivatives off to order m - 1 vanish there.
      
@@ -1922,7 +1922,7 @@ 
      Essential Classes in sympy.vector (docstrings)reg_point=None,
      
 
      
 
-)[source]
+)[source]
 
      Returns the rational parametrization of implicit region.
      
 
      Examples
      
 
      >>> from sympy import Eq
@@ -1973,7 +1973,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-regular_point()[source]
      
+regular_point()[source]
 
      Returns a point on the implicit region.
      
 
      Examples
      
 
      >>> from sympy.abc import x, y, z
@@ -1999,7 +1999,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-singular_points()[source]
      
+singular_points()[source]
 
      Returns a set of singular points of the region.
      
 
      The singular points are those points on the region
 where all partial derivatives vanish.
      
@@ -2017,7 +2017,7 @@ 
      Essential Classes in sympy.vector (docstrings)
 
      
-class sympy.vector.integrals.ParametricIntegral(field, parametricregion)[source]
      
+class sympy.vector.integrals.ParametricIntegral(field, parametricregion)[source]
 
      Represents integral of a scalar or vector field
 over a Parametric Region
      
 
      Examples
      
diff --git a/dev/modules/vector/api/orienterclasses.html b/dev/modules/vector/api/orienterclasses.html
index 2c006f41fd6..a8211463eee 100644
--- a/dev/modules/vector/api/orienterclasses.html
+++ b/dev/modules/vector/api/orienterclasses.html
@@ -802,11 +802,11 @@ 
      Documentation Version
      
 
      Orienter classes (docstrings)
      
 
      
 
      
-class sympy.vector.orienters.Orienter(*args)[source]
      
+class sympy.vector.orienters.Orienter(*args)[source]
 
      Super-class for all orienter classes.
      
 
      
 
      
-rotation_matrix()[source]
      
+rotation_matrix()[source]
 
      The rotation matrix corresponding to this orienter
 instance.
      
 
      
@@ -815,11 +815,11 @@ 
      Orienter classes (docstrings)
 
      
-class sympy.vector.orienters.AxisOrienter(angle, axis)[source]
      
+class sympy.vector.orienters.AxisOrienter(angle, axis)[source]
 
      Class to denote an axis orienter.
      
 
      
 
      
-__init__(angle, axis)[source]
      
+__init__(angle, axis)[source]
 
      Axis rotation is a rotation about an arbitrary axis by
 some angle. The angle is supplied as a SymPy expr scalar, and
 the axis is supplied as a Vector.
      
@@ -849,7 +849,7 @@ 
      Orienter classes (docstrings)
 
      
-rotation_matrix(system)[source]
      
+rotation_matrix(system)[source]
 
      The rotation matrix corresponding to this orienter
 instance.
      
 
      
@@ -867,7 +867,7 @@ 
      Orienter classes (docstrings)
 
      
-class sympy.vector.orienters.BodyOrienter(angle1, angle2, angle3, rot_order)[source]
      
+class sympy.vector.orienters.BodyOrienter(angle1, angle2, angle3, rot_order)[source]
 
      Class to denote a body-orienter.
      
 
      
 
      
@@ -880,7 +880,7 @@ 
      Orienter classes (docstrings)rot_order,
      
 
      
 
-)[source]
+)[source]
 
      Body orientation takes this coordinate system through three
 successive simple rotations.
      
 
      Body fixed rotations include both Euler Angles and
@@ -938,7 +938,7 @@ 
      Orienter classes (docstrings)
 
      
-class sympy.vector.orienters.SpaceOrienter(angle1, angle2, angle3, rot_order)[source]
      
+class sympy.vector.orienters.SpaceOrienter(angle1, angle2, angle3, rot_order)[source]
 
      Class to denote a space-orienter.
      
 
      
 
      
@@ -951,7 +951,7 @@ 
      Orienter classes (docstrings)rot_order,
      
 
      
 
-)[source]
+)[source]
 
      Space rotation is similar to Body rotation, but the rotations
 are applied in the opposite order.
      
 
      
@@ -1005,7 +1005,7 @@ 
      Orienter classes (docstrings)
 
      
-class sympy.vector.orienters.QuaternionOrienter(q0, q1, q2, q3)[source]
      
+class sympy.vector.orienters.QuaternionOrienter(q0, q1, q2, q3)[source]
 
      Class to denote a quaternion-orienter.
      
 
      
 
      
@@ -1018,7 +1018,7 @@ 
      Orienter classes (docstrings)rot_order,
      
 
      
 
-)[source]
+)[source]
 
      Quaternion orientation orients the new CoordSys3D with
 Quaternions, defined as a finite rotation about lambda, a unit
 vector, by some amount theta.
      
diff --git a/dev/modules/vector/api/vectorfunctions.html b/dev/modules/vector/api/vectorfunctions.html
index 0e1125e6a58..932615e0740 100644
--- a/dev/modules/vector/api/vectorfunctions.html
+++ b/dev/modules/vector/api/vectorfunctions.html
@@ -802,7 +802,7 @@ 
      Documentation Version
      
 
      Essential Functions in sympy.vector (docstrings)
      
 
      
 
      
-sympy.vector.matrix_to_vector(matrix, system)[source]
      
+sympy.vector.matrix_to_vector(matrix, system)[source]
 
      Converts a vector in matrix form to a Vector instance.
      
 
      It is assumed that the elements of the Matrix represent the
 measure numbers of the components of the vector along basis
@@ -844,7 +844,7 @@ 
      Essential Functions in sympy.vector (docstrings)variables=False,
      
 
      
 
-)[source]
+)[source]
 
      Global function for ‘express’ functionality.
      
 
      Re-expresses a Vector, Dyadic or scalar(sympyfiable) in the given
 coordinate system.
      
@@ -894,7 +894,7 @@ 
      Essential Functions in sympy.vector (docstrings)
 
      
-sympy.vector.curl(vect, doit=True)[source]
      
+sympy.vector.curl(vect, doit=True)[source]
 
      Returns the curl of a vector field computed wrt the base scalars
 of the given coordinate system.
      
 
      
@@ -926,7 +926,7 @@ 
      Essential Functions in sympy.vector (docstrings)
 
      
-sympy.vector.divergence(vect, doit=True)[source]
      
+sympy.vector.divergence(vect, doit=True)[source]
 
      Returns the divergence of a vector field computed wrt the base
 scalars of the given coordinate system.
      
 
      
@@ -960,7 +960,7 @@ 
      Essential Functions in sympy.vector (docstrings)
 
      
-sympy.vector.gradient(scalar_field, doit=True)[source]
      
+sympy.vector.gradient(scalar_field, doit=True)[source]
 
      Returns the vector gradient of a scalar field computed wrt the
 base scalars of the given coordinate system.
      
 
      
@@ -992,7 +992,7 @@ 
      Essential Functions in sympy.vector (docstrings)
 
      
-sympy.vector.is_conservative(field)[source]
      
+sympy.vector.is_conservative(field)[source]
 
      Checks if a field is conservative.
      
 
      
 
      Parameters:
      
@@ -1016,7 +1016,7 @@ 
      Essential Functions in sympy.vector (docstrings)
 
      
-sympy.vector.is_solenoidal(field)[source]
      
+sympy.vector.is_solenoidal(field)[source]
 
      Checks if a field is solenoidal.
      
 
      
 
      Parameters:
      
@@ -1040,7 +1040,7 @@ 
      Essential Functions in sympy.vector (docstrings)
 
      
-sympy.vector.scalar_potential(field, coord_sys)[source]
      
+sympy.vector.scalar_potential(field, coord_sys)[source]
 
      Returns the scalar potential function of a field in a given
 coordinate system (without the added integration constant).
      
 
      
@@ -1081,7 +1081,7 @@ 
      Essential Functions in sympy.vector (docstrings)point2,
      
 
      
 
-)[source]
+)[source]
 
      Returns the scalar potential difference between two points in a
 certain coordinate system, wrt a given field.
      
 
      If a scalar field is provided, its values at the two points are
@@ -1127,7 +1127,7 @@ 
      Essential Functions in sympy.vector (docstrings)
 
      
-sympy.vector.integrals.vector_integrate(field, *region)[source]
      
+sympy.vector.integrals.vector_integrate(field, *region)[source]
 
      Compute the integral of a vector/scalar field
 over a a region or a set of parameters.
      
 
      Examples