Upload folder using huggingface_hub (part 20)

.gitattributes

@@ -435,3 +435,4 @@ venv/lib/python3.11/site-packages/scipy.libs/libquadmath-828275a7.so.0.0.0 filte
 venv/lib/python3.11/site-packages/scipy.libs/libquadmath-96973f99-934c22de.so.0.0.0 filter=lfs diff=lfs merge=lfs -text
 venv/lib/python3.11/site-packages/scipy.libs/libscipy_openblas-6cdc3b4a.so filter=lfs diff=lfs merge=lfs -text
 venv/lib/python3.11/site-packages/sentencepiece/_sentencepiece.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/tokenizers/tokenizers.abi3.so filter=lfs diff=lfs merge=lfs -text

venv/lib/python3.11/site-packages/sympy-1.14.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

venv/lib/python3.11/site-packages/sympy-1.14.0.dist-info/METADATA

@@ -0,0 +1,319 @@
+Metadata-Version: 2.4
+Name: sympy
+Version: 1.14.0
+Summary: Computer algebra system (CAS) in Python
+Home-page: https://sympy.org
+Author: SymPy development team
+Author-email: sympy@googlegroups.com
+License: BSD
+Project-URL: Source, https://github.com/sympy/sympy
+Keywords: Math CAS
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS
+Requires-Dist: mpmath<1.4,>=1.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.1.0; extra == "dev"
+Requires-Dist: hypothesis>=6.70.0; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# SymPy
+
+[![pypi version](https://img.shields.io/pypi/v/sympy.svg)](https://pypi.python.org/pypi/sympy)
+[![Join the chat at https://gitter.im/sympy/sympy](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/sympy/sympy?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Zenodo Badge](https://zenodo.org/badge/18918/sympy/sympy.svg)](https://zenodo.org/badge/latestdoi/18918/sympy/sympy)
+[![Downloads](https://pepy.tech/badge/sympy/month)](https://pepy.tech/project/sympy)
+[![GitHub Issues](https://img.shields.io/badge/issue_tracking-github-blue.svg)](https://github.com/sympy/sympy/issues)
+[![Git Tutorial](https://img.shields.io/badge/PR-Welcome-%23FF8300.svg?)](https://git-scm.com/book/en/v2/GitHub-Contributing-to-a-Project)
+[![Powered by NumFocus](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org)
+[![Commits since last release](https://img.shields.io/github/commits-since/sympy/sympy/latest.svg?longCache=true&style=flat-square&logo=git&logoColor=fff)](https://github.com/sympy/sympy/releases)
+
+[![SymPy Banner](https://github.com/sympy/sympy/raw/master/banner.svg)](https://sympy.org/)
+
+
+See the [AUTHORS](AUTHORS) file for the list of authors.
+
+And many more people helped on the SymPy mailing list, reported bugs,
+helped organize SymPy's participation in the Google Summer of Code, the
+Google Highly Open Participation Contest, Google Code-In, wrote and
+blogged about SymPy...
+
+License: New BSD License (see the [LICENSE](LICENSE) file for details) covers all
+files in the sympy repository unless stated otherwise.
+
+Our mailing list is at
+<https://groups.google.com/forum/?fromgroups#!forum/sympy>.
+
+We have a community chat at [Gitter](https://gitter.im/sympy/sympy). Feel
+free to ask us anything there. We have a very welcoming and helpful
+community.
+
+## Download
+
+The recommended installation method is through Anaconda,
+<https://www.anaconda.com/products/distribution>
+
+You can also get the latest version of SymPy from
+<https://pypi.python.org/pypi/sympy/>
+
+To get the git version do
+
+    $ git clone https://github.com/sympy/sympy.git
+
+For other options (tarballs, debs, etc.), see
+<https://docs.sympy.org/dev/install.html>.
+
+## Documentation and Usage
+
+For in-depth instructions on installation and building the
+documentation, see the [SymPy Documentation Style Guide](https://docs.sympy.org/dev/documentation-style-guide.html).
+
+Everything is at:
+
+<https://docs.sympy.org/>
+
+You can generate everything at the above site in your local copy of
+SymPy by:
+
+    $ cd doc
+    $ make html
+
+Then the docs will be in <span class="title-ref">\_build/html</span>. If
+you don't want to read that, here is a short usage:
+
+From this directory, start Python and:
+
+``` python
+>>> from sympy import Symbol, cos
+>>> x = Symbol('x')
+>>> e = 1/cos(x)
+>>> print(e.series(x, 0, 10))
+1 + x**2/2 + 5*x**4/24 + 61*x**6/720 + 277*x**8/8064 + O(x**10)
+```
+
+SymPy also comes with a console that is a simple wrapper around the
+classic python console (or IPython when available) that loads the SymPy
+namespace and executes some common commands for you.
+
+To start it, issue:
+
+    $ bin/isympy
+
+from this directory, if SymPy is not installed or simply:
+
+    $ isympy
+
+if SymPy is installed.
+
+## Installation
+
+To install SymPy using PyPI, run the following command:
+
+    $ pip install sympy
+
+To install SymPy using Anaconda, run the following command:
+
+    $ conda install -c anaconda sympy
+
+To install SymPy from GitHub source, first clone SymPy using `git`:
+
+    $ git clone https://github.com/sympy/sympy.git
+
+Then, in the `sympy` repository that you cloned, simply run:
+
+    $ pip install .
+
+See <https://docs.sympy.org/dev/install.html> for more information.
+
+## Contributing
+
+We welcome contributions from anyone, even if you are new to open
+source. Please read our [Introduction to Contributing](https://docs.sympy.org/dev/contributing/introduction-to-contributing.html)
+page and the [SymPy Documentation Style Guide](https://docs.sympy.org/dev/documentation-style-guide.html). If you
+are new and looking for some way to contribute, a good place to start is
+to look at the issues tagged [Easy to Fix](https://github.com/sympy/sympy/issues?q=is%3Aopen+is%3Aissue+label%3A%22Easy+to+Fix%22).
+
+Please note that all participants in this project are expected to follow
+our Code of Conduct. By participating in this project you agree to abide
+by its terms. See [CODE\_OF\_CONDUCT.md](CODE_OF_CONDUCT.md).
+
+## Tests
+
+To execute all tests, run:
+
+    $./setup.py test
+
+in the current directory.
+
+For the more fine-grained running of tests or doctests, use `bin/test`
+or respectively `bin/doctest`. The master branch is automatically tested
+by GitHub Actions.
+
+To test pull requests, use
+[sympy-bot](https://github.com/sympy/sympy-bot).
+
+## Regenerate Experimental <span class="title-ref">LaTeX</span> Parser/Lexer
+
+The parser and lexer were generated with the [ANTLR4](http://antlr4.org)
+toolchain in `sympy/parsing/latex/_antlr` and checked into the repo.
+Presently, most users should not need to regenerate these files, but
+if you plan to work on this feature, you will need the `antlr4`
+command-line tool (and you must ensure that it is in your `PATH`).
+One way to get it is:
+
+    $ conda install -c conda-forge antlr=4.11.1
+
+Alternatively, follow the instructions on the ANTLR website and download
+the `antlr-4.11.1-complete.jar`. Then export the `CLASSPATH` as instructed
+and instead of creating `antlr4` as an alias, make it an executable file
+with the following contents:
+``` bash
+#!/bin/bash
+java -jar /usr/local/lib/antlr-4.11.1-complete.jar "$@"
+```
+
+After making changes to `sympy/parsing/latex/LaTeX.g4`, run:
+
+    $ ./setup.py antlr
+
+## Clean
+
+To clean everything (thus getting the same tree as in the repository):
+
+    $ git clean -Xdf
+
+which will clear everything ignored by `.gitignore`, and:
+
+    $ git clean -df
+
+to clear all untracked files. You can revert the most recent changes in
+git with:
+
+    $ git reset --hard
+
+WARNING: The above commands will all clear changes you may have made,
+and you will lose them forever. Be sure to check things with `git
+status`, `git diff`, `git clean -Xn`, and `git clean -n` before doing any
+of those.
+
+## Bugs
+
+Our issue tracker is at <https://github.com/sympy/sympy/issues>. Please
+report any bugs that you find. Or, even better, fork the repository on
+GitHub and create a pull request. We welcome all changes, big or small,
+and we will help you make the pull request if you are new to git (just
+ask on our mailing list or Gitter Channel). If you further have any queries, you can find answers
+on Stack Overflow using the [sympy](https://stackoverflow.com/questions/tagged/sympy) tag.
+
+## Brief History
+
+SymPy was started by Ondřej Čertík in 2005, he wrote some code during
+the summer, then he wrote some more code during summer 2006. In February
+2007, Fabian Pedregosa joined the project and helped fix many things,
+contributed documentation, and made it alive again. 5 students (Mateusz
+Paprocki, Brian Jorgensen, Jason Gedge, Robert Schwarz, and Chris Wu)
+improved SymPy incredibly during summer 2007 as part of the Google
+Summer of Code. Pearu Peterson joined the development during the summer
+2007 and he has made SymPy much more competitive by rewriting the core
+from scratch, which has made it from 10x to 100x faster. Jurjen N.E. Bos
+has contributed pretty-printing and other patches. Fredrik Johansson has
+written mpmath and contributed a lot of patches.
+
+SymPy has participated in every Google Summer of Code since 2007. You
+can see <https://github.com/sympy/sympy/wiki#google-summer-of-code> for
+full details. Each year has improved SymPy by bounds. Most of SymPy's
+development has come from Google Summer of Code students.
+
+In 2011, Ondřej Čertík stepped down as lead developer, with Aaron
+Meurer, who also started as a Google Summer of Code student, taking his
+place. Ondřej Čertík is still active in the community but is too busy
+with work and family to play a lead development role.
+
+Since then, a lot more people have joined the development and some
+people have also left. You can see the full list in doc/src/aboutus.rst,
+or online at:
+
+<https://docs.sympy.org/dev/aboutus.html#sympy-development-team>
+
+The git history goes back to 2007 when development moved from svn to hg.
+To see the history before that point, look at
+<https://github.com/sympy/sympy-old>.
+
+You can use git to see the biggest developers. The command:
+
+    $ git shortlog -ns
+
+will show each developer, sorted by commits to the project. The command:
+
+    $ git shortlog -ns --since="1 year"
+
+will show the top developers from the last year.
+
+## Citation
+
+To cite SymPy in publications use
+
+> Meurer A, Smith CP, Paprocki M, Čertík O, Kirpichev SB, Rocklin M,
+> Kumar A, Ivanov S, Moore JK, Singh S, Rathnayake T, Vig S, Granger BE,
+> Muller RP, Bonazzi F, Gupta H, Vats S, Johansson F, Pedregosa F, Curry
+> MJ, Terrel AR, Roučka Š, Saboo A, Fernando I, Kulal S, Cimrman R,
+> Scopatz A. (2017) SymPy: symbolic computing in Python. *PeerJ Computer
+> Science* 3:e103 <https://doi.org/10.7717/peerj-cs.103>
+
+A BibTeX entry for LaTeX users is
+
+``` bibtex
+@article{10.7717/peerj-cs.103,
+ title = {SymPy: symbolic computing in Python},
+ author = {Meurer, Aaron and Smith, Christopher P. and Paprocki, Mateusz and \v{C}ert\'{i}k, Ond\v{r}ej and Kirpichev, Sergey B. and Rocklin, Matthew and Kumar, Amit and Ivanov, Sergiu and Moore, Jason K. and Singh, Sartaj and Rathnayake, Thilina and Vig, Sean and Granger, Brian E. and Muller, Richard P. and Bonazzi, Francesco and Gupta, Harsh and Vats, Shivam and Johansson, Fredrik and Pedregosa, Fabian and Curry, Matthew J. and Terrel, Andy R. and Rou\v{c}ka, \v{S}t\v{e}p\'{a}n and Saboo, Ashutosh and Fernando, Isuru and Kulal, Sumith and Cimrman, Robert and Scopatz, Anthony},
+ year = 2017,
+ month = Jan,
+ keywords = {Python, Computer algebra system, Symbolics},
+ abstract = {
+            SymPy is an open-source computer algebra system written in pure Python. It is built with a focus on extensibility and ease of use, through both interactive and programmatic applications. These characteristics have led SymPy to become a popular symbolic library for the scientific Python ecosystem. This paper presents the architecture of SymPy, a description of its features, and a discussion of select submodules. The supplementary material provides additional examples and further outlines details of the architecture and features of SymPy.
+         },
+ volume = 3,
+ pages = {e103},
+ journal = {PeerJ Computer Science},
+ issn = {2376-5992},
+ url = {https://doi.org/10.7717/peerj-cs.103},
+ doi = {10.7717/peerj-cs.103}
+}
+```
+
+SymPy is BSD licensed, so you are free to use it whatever you like, be
+it academic, commercial, creating forks or derivatives, as long as you
+copy the BSD statement if you redistribute it (see the LICENSE file for
+details). That said, although not required by the SymPy license, if it
+is convenient for you, please cite SymPy when using it in your work and
+also consider contributing all your changes back, so that we can
+incorporate it and all of us will benefit in the end.

venv/lib/python3.11/site-packages/sympy-1.14.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (79.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

venv/lib/python3.11/site-packages/sympy-1.14.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+isympy = isympy:main

venv/lib/python3.11/site-packages/sympy-1.14.0.dist-info/licenses/AUTHORS

@@ -0,0 +1,1379 @@
+All people who contributed to SymPy by sending at least a patch or
+more (in the order of the date of their first contribution), except
+those who explicitly didn't want to be mentioned. People with a * next
+to their names are not found in the metadata of the git history. This
+file is generated automatically by running `./bin/authors_update.py`.
+
+There are a total of 1371 authors.
+
+Ondřej Čertík <ondrej@certik.cz>
+Fabian Pedregosa <fabian@fseoane.net>
+Jurjen N.E. Bos <jnebos@gmail.com>
+Mateusz Paprocki <mattpap@gmail.com>
+*Marc-Etienne M.Leveille <protonyc@gmail.com>
+Brian Jorgensen <brian.jorgensen@gmail.com>
+Jason Gedge <inferno1386@gmail.com>
+Robert Schwarz <lethargo@googlemail.com>
+Pearu Peterson <pearu.peterson@gmail.com>
+Fredrik Johansson <fredrik.johansson@gmail.com>
+Chris Wu <chris.wu@gmail.com>
+*Ulrich Hecht <ulrich.hecht@gmail.com>
+Goutham Lakshminarayan <dl.goutham@gmail.com>
+David Lawrence <dmlawrence@gmail.com>
+Jaroslaw Tworek <dev.jrx@gmail.com>
+David Marek <h4wk.cz@gmail.com>
+Bernhard R. Link <brlink@debian.org>
+Andrej Tokarčík <androsis@gmail.com>
+Or Dvory <gidesa@gmail.com>
+Saroj Adhikari <adh.saroj@gmail.com>
+Pauli Virtanen <pav@iki.fi>
+Robert Kern <robert.kern@gmail.com>
+James Aspnes <aspnes@cs.yale.edu>
+Nimish Telang <ntelang@gmail.com>
+Abderrahim Kitouni <a.kitouni@gmail.com>
+Pan Peng <pengpanster@gmail.com>
+Friedrich Hagedorn <friedrich_h@gmx.de>
+Elrond der Elbenfuerst <elrond+sympy.org@samba-tng.org>
+Rizgar Mella <rizgar.mella@gmail.com>
+Felix Kaiser <felix.kaiser@fxkr.net>
+Roberto Nobrega <rwnobrega@gmail.com>
+David Roberts <dvdr18@gmail.com>
+Sebastian Krämer <basti.kr@gmail.com>
+Vinzent Steinberg <vinzent.steinberg@gmail.com>
+Riccardo Gori <goriccardo@gmail.com>
+Case Van Horsen <casevh@gmail.com>
+Stepan Roucka <stepan@roucka.eu>
+Ali Raza Syed <arsyed@gmail.com>
+Stefano Maggiolo <s.maggiolo@gmail.com>
+Robert Cimrman <cimrman3@ntc.zcu.cz>
+Bastian Weber <bastian.weber@gmx-topmail.de>
+Sebastian Krause <sebastian.krause@gmx.de>
+Sebastian Kreft <skreft@gmail.com>
+*Dan <coolg49964@gmail.com>
+Alan Bromborsky <abrombo@verizon.net>
+Boris Timokhin <qoqenator@gmail.com>
+Robert <average.programmer@gmail.com>
+Andy R. Terrel <aterrel@uchicago.edu>
+Hubert Tsang <intsangity@gmail.com>
+Konrad Meyer <konrad.meyer@gmail.com>
+Henrik Johansson <henjo2006@gmail.com>
+Priit Laes <plaes@plaes.org>
+Freddie Witherden <freddie@witherden.org>
+Brian E. Granger <ellisonbg@gmail.com>
+Andrew Straw <strawman@astraw.com>
+Kaifeng Zhu <cafeeee@gmail.com>
+Ted Horst <ted.horst@earthlink.net>
+Andrew Docherty <andrewd@maths.usyd.edu.au>
+Akshay Srinivasan <akshaysrinivasan@gmail.com>
+Aaron Meurer <asmeurer@gmail.com>
+Barry Wardell <barry.wardell@gmail.com>
+Tomasz Buchert <thinred@gmail.com>
+Vinay Kumar <gnulinooks@gmail.com>
+Johann Cohen-Tanugi <johann.cohentanugi@gmail.com>
+Jochen Voss <voss@seehuhn.de>
+Luke Peterson <hazelnusse@gmail.com>
+Chris Smith <smichr@gmail.com>
+Thomas Sidoti <TSidoti@gmail.com>
+Florian Mickler <florian@mickler.org>
+Nicolas Pourcelot <nicolas.pourcelot@gmail.com>
+Ben Goodrich <goodrich.ben@gmail.com>
+Toon Verstraelen <Toon.Verstraelen@UGent.be>
+Ronan Lamy <ronan.lamy@gmail.com>
+James Abbatiello <abbeyj@gmail.com>
+Ryan Krauss <ryanlists@gmail.com>
+Bill Flynn <wflynny@gmail.com>
+Kevin Goodsell <kevin-opensource@omegacrash.net>
+Jorn Baayen <jorn.baayen@gmail.com>
+Eh Tan <tan2tan2@gmail.com>
+Renato Coutinho <renato.coutinho@gmail.com>
+Oscar Benjamin <oscar.j.benjamin@gmail.com>
+Øyvind Jensen <jensen.oyvind@gmail.com>
+Julio Idichekop Filho <idichekop@yahoo.com.br>
+Łukasz Pankowski <lukpank@o2.pl>
+*Chu-Ching Huang <cchuang@mail.cgu.edu.tw>
+Fernando Perez <Fernando.Perez@berkeley.edu>
+Raffaele De Feo <alberthilbert@gmail.com>
+Christian Muise <christian.muise@gmail.com>
+Matt Curry <mattjcurry@gmail.com>
+Kazuo Thow <kazuo.thow@gmail.com>
+Christian Schubert <chr.schubert@gmx.de>
+Jezreel Ng <jezreel@gmail.com>
+James Pearson <xiong.chiamiov@gmail.com>
+Matthew Brett <matthew.brett@gmail.com>
+Addison Cugini <ajcugini@gmail.com>
+Nicholas J.S. Kinar <n.kinar@usask.ca>
+Harold Erbin <harold.erbin@gmail.com>
+Thomas Dixon <thom@thomdixon.org>
+Cristóvão Sousa <crisjss@gmail.com>
+Andre de Fortier Smit <freevryheid@gmail.com>
+Mark Dewing <markdewing@gmail.com>
+Alexey U. Gudchenko <proga@goodok.ru>
+Gary Kerr <gary.kerr@blueyonder.co.uk>
+Sherjil Ozair <sherjilozair@gmail.com>
+Oleksandr Gituliar <gituliar@gmail.com>
+Sean Vig <sean.v.775@gmail.com>
+Prafullkumar P. Tale <hector1618@gmail.com>
+Vladimir Perić <vlada.peric@gmail.com>
+Tom Bachmann <e_mc_h2@web.de>
+Yuri Karadzhov <yuri.karadzhov@gmail.com>
+Vladimir Lagunov <werehuman@gmail.com>
+Matthew Rocklin <mrocklin@cs.uchicago.edu>
+Saptarshi Mandal <sapta.iitkgp@gmail.com>
+Gilbert Gede <gilbertgede@gmail.com>
+Anatolii Koval <weralwolf@gmail.com>
+Tomo Lazovich <lazovich@gmail.com>
+Pavel Fedotov <fedotovp@gmail.com>
+Jack McCaffery <jpmccaffery@gmail.com>
+Jeremias Yehdegho <j.yehdegho@gmail.com>
+Kibeom Kim <kk1674@nyu.edu>
+Gregory Ksionda <ksiondag846@gmail.com>
+Tomáš Bambas <tomas.bambas@gmail.com>
+Raymond Wong <rayman_407@yahoo.com>
+Luca Weihs <astronomicalcuriosity@gmail.com>
+Shai 'Deshe' Wyborski <shaide@cs.huji.ac.il>
+Thomas Wiecki <thomas.wiecki@gmail.com>
+Óscar Nájera <najera.oscar@gmail.com>
+Mario Pernici <mario.pernici@gmail.com>
+Benjamin McDonald <mcdonald.ben@gmail.com>
+Sam Magura <samtheman132@gmail.com>
+Stefan Krastanov <krastanov.stefan@gmail.com>
+Bradley Froehle <brad.froehle@gmail.com>
+Min Ragan-Kelley <benjaminrk@gmail.com>
+Emma Hogan <ehogan@gemini.edu>
+Nikhil Sarda <diff.operator@gmail.com>
+Julien Rioux <julien.rioux@gmail.com>
+Roberto Colistete, Jr. <roberto.colistete@gmail.com>
+Raoul Bourquin <raoulb@bluewin.ch>
+Gert-Ludwig Ingold <gert.ingold@physik.uni-augsburg.de>
+Srinivas Vasudevan <srvasude@gmail.com>
+Jason Moore <moorepants@gmail.com>
+Miha Marolt <tloramus@gmail.com>
+Tim Lahey <tim.lahey@gmail.com>
+Luis Garcia <ppn.online@me.com>
+Matt Rajca <matt.rajca@me.com>
+David Li <l33tnerd.li@gmail.com>
+Alexandr Gudulin <alexandr.gudulin@gmail.com>
+Bilal Akhtar <bilalakhtar@ubuntu.com>
+Grzegorz Świrski <sognat@gmail.com>
+Matt Habel <habelinc@gmail.com>
+David Ju <Sgtmook314@gmail.com>
+Nichita Utiu <nikita.utiu+github@gmail.com>
+Nikolay Lazarov <qwerqwerqwer@abv.bg>
+Steve Anton <anxuiz.nx@gmail.com>
+Imran Ahmed Manzoor <imran.manzoor31@gmail.com>
+Ljubiša Moćić <3rdslasher@gmail.com>
+Piotr Korgul <p.korgul@gmail.com>
+Jim Zhang <Hyriodula@gmail.com>
+Sam Sleight <samuel.sleight@gmail.com>
+tborisova <ts.borisova3@gmail.com>
+Chancellor Arkantos <Chancellor_Arkantos@hotmail.co.uk>
+Stepan Simsa <simsa.st@gmail.com>
+Tobias Lenz <t_lenz94@web.de>
+Siddhanathan Shanmugam <siddhanathan@gmail.com>
+Tiffany Zhu <bubble.wubble.303@gmail.com>
+Tristan Hume <tris.hume@gmail.com>
+Alexey Subach <alexey.subach@gmail.com>
+Joan Creus <joan.creus.c@gmail.com>
+Geoffry Song <goffrie@gmail.com>
+Puneeth Chaganti <punchagan@gmail.com>
+Marcin Kostrzewa <>
+Natalia Nawara <fankalemura@gmail.com>
+vishal <vishal.panjwani15@gmail.com>
+Shruti Mangipudi <shruti2395@gmail.com>
+Davy Mao <e_equals_mass_speed_light_squared@hotmail.com>
+Swapnil Agarwal <swapnilag29@gmail.com>
+Dhia Kennouche <kendhia@gmail.com>
+jerryma1121 <jerryma1121@gmail.com>
+Joachim Durchholz <jo@durchholz.org>
+Martin Povišer <martin.povik@gmail.com>
+Siddhant Jain <getsiddhant@gmail.com>
+Kevin Hunter <hunteke@earlham.edu>
+Michael Mayorov <marchael@kb.csu.ru>
+Nathan Alison <nathan.f.alison@gmail.com>
+Christian Bühler <christian@cbuehler.de>
+Carsten Knoll <CarstenKnoll@gmx.de>
+Bharath M R <catchmrbharath@gmail.com>
+Matthias Toews <mat.toews@googlemail.com>
+Sergiu Ivanov <unlimitedscolobb@gmail.com>
+Jorge E. Cardona <jorgeecardona@gmail.com>
+Sanket Agarwal <sanket@sanketagarwal.com>
+Manoj Babu K. <manoj.babu2378@gmail.com>
+Sai Nikhil <tsnlegend@gmail.com>
+Aleksandar Makelov <amakelov@college.harvard.edu>
+Sachin Irukula <sachin.irukula@gmail.com>
+Raphael Michel <webmaster@raphaelmichel.de>
+Ashwini Oruganti <ashwini.oruganti@gmail.com>
+Andreas Klöckner <inform@tiker.net>
+Prateek Papriwal <papriwalprateek@gmail.com>
+Arpit Goyal <agmps18@gmail.com>
+Angadh Nanjangud <angadh.n@gmail.com>
+Comer Duncan <comer.duncan@gmail.com>
+Jens H. Nielsen <jenshnielsen@gmail.com>
+Joseph Dougherty <Github@JWDougherty.com>
+Elliot Marshall <Marshall2389@gmail.com>
+Guru Devanla <grdvnl@gmail.com>
+George Waksman <waksman@gwax.com>
+Alexandr Popov <alexandr.s.popov@gmail.com>
+Tarun Gaba <tarun.gaba7@gmail.com>
+Takafumi Arakaki <aka.tkf@gmail.com>
+Saurabh Jha <saurabh.jhaa@gmail.com>
+Rom le Clair <jacen.guardian@gmail.com>
+Angus Griffith <16sn6uv@gmail.com>
+Timothy Reluga <treluga@math.psu.edu>
+Brian Stephanik <xoedusk@gmail.com>
+Alexander Eberspächer <alex.eberspaecher@gmail.com>
+Sachin Joglekar <srjoglekar246@gmail.com>
+Tyler Pirtle <teeler@gmail.com>
+Vasily Povalyaev <vapovalyaev@gmail.com>
+Colleen Lee <colleenclee@gmail.com>
+Matthew Hoff <mhoff14@gmail.com>
+Niklas Thörne <notrupertthorne@gmail.com>
+Huijun Mai <m.maihuijun@gmail.com>
+Marek Šuppa <mr@shu.io>
+Ramana Venkata <idlike2dream@gmail.com>
+Prasoon Shukla <prasoon92.iitr@gmail.com>
+Stefen Yin <zqyin@ucdavis.edu>
+Thomas Hisch <t.hisch@gmail.com>
+Madeleine Ball <mpball@gmail.com>
+Mary Clark <mary.spriteling@gmail.com>
+Rishabh Dixit <rishabhdixit11@gmail.com>
+Manoj Kumar <manojkumarsivaraj334@gmail.com>
+Akshit Agarwal <akshit.jiit@gmail.com>
+CJ Carey <perimosocordiae@gmail.com>
+Patrick Lacasse <patrick.m.lacasse@gmail.com>
+Ananya H <ananyaha93@gmail.com>
+Tarang Patel <tarangrockr@gmail.com>
+Christopher Dembia <cld72@cornell.edu>
+Benjamin Fishbein <fishbeinb@gmail.com>
+Sean Ge <seange727@gmail.com>
+Amit Jamadagni <bitsjamadagni@gmail.com>
+Ankit Agrawal <aaaagrawal@iitb.ac.in>
+Björn Dahlgren <bjodah@gmail.com>
+Christophe Saint-Jean <christophe.saint-jean@univ-lr.fr>
+Demian Wassermann <demian@bwh.harvard.edu>
+Khagesh Patel <khageshpatel93@gmail.com>
+Stephen Loo <shikil@yahoo.com>
+hm <hacman0@gmail.com>
+Patrick Poitras <acebulf@gmail.com>
+Katja Sophie Hotz <katja.sophie.hotz@student.tuwien.ac.at>
+Varun Joshi <joshi.142@osu.edu>
+Chetna Gupta <cheta.gup@gmail.com>
+Thilina Rathnayake <thilinarmtb@gmail.com>
+Max Hutchinson <maxhutch@gmail.com>
+Shravas K Rao <shravas@gmail.com>
+Matthew Tadd <matt.tadd@gmail.com>
+Alexander Hirzel <alex@hirzel.us>
+Randy Heydon <randy.heydon@clockworklab.net>
+Oliver Lee <oliverzlee@gmail.com>
+Seshagiri Prabhu <seshagiriprabhu@gmail.com>
+Pradyumna <pradyu1993@gmail.com>
+Erik Welch <erik.n.welch@gmail.com>
+Eric Nelson <eric.the.red.XLII@gmail.com>
+Roland Puntaier <roland.puntaier@chello.at>
+Chris Conley <chrisconley15@gmail.com>
+Tim Swast <tswast@gmail.com>
+Dmitry Batkovich <batya239@gmail.com>
+Francesco Bonazzi <franz.bonazzi@gmail.com>
+Yuriy Demidov <iurii.demidov@gmail.com>
+Rick Muller <rpmuller@gmail.com>
+Manish Gill <gill.manish90@gmail.com>
+Markus Müller <markus.mueller.1.g@googlemail.com>
+Amit Saha <amitsaha.in@gmail.com>
+Jeremy <twobitlogic@gmail.com>
+QuaBoo <kisonchristian@gmail.com>
+Stefan van der Walt <stefan@sun.ac.za>
+David Joyner <wdjoyner@gmail.com>
+Lars Buitinck <larsmans@gmail.com>
+Alkiviadis G. Akritas <akritas@uth.gr>
+Vinit Ravishankar <vinit.ravishankar@gmail.com>
+Michael Boyle <michael.oliver.boyle@gmail.com>
+Heiner Kirchhoffer <Heiner.Kirchhoffer@gmail.com>
+Pablo Puente <ppuedom@gmail.com>
+James Fiedler <jrfiedler@gmail.com>
+Harsh Gupta <mail@hargup.in>
+Tuomas Airaksinen <tuomas.airaksinen@gmail.com>
+Paul Strickland <p.e.strickland@gmail.com>
+James Goppert <james.goppert@gmail.com>
+rathmann <rathmann.os@gmail.com>
+Avichal Dayal <avichal.dayal@gmail.com>
+Paul Scott <paul.scott@nicta.com.au>
+Shipra Banga <bangashipra@gmail.com>
+Pramod Ch <pramodch14@gmail.com>
+Akshay <akshaynukala95@gmail.com>
+Buck Shlegeris <buck2@bruceh15.anu.edu.au>
+Jonathan Miller <jdmiller93@gmail.com>
+Edward Schembor <eschemb1@jhu.edu>
+Rajath Shashidhara <rajaths.rajaths@gmail.com>
+Zamrath Nizam <zamiguy_ni@yahoo.com>
+Aditya Shah <adityashah30@gmail.com>
+Rajat Aggarwal <rajataggarwal1975@gmail.com>
+Sambuddha Basu <sammygamer@live.com>
+Zeel Shah <kshah215@gmail.com>
+Abhinav Chanda <abhinavchanda01@gmail.com>
+Jim Crist <crist042@umn.edu>
+Sudhanshu Mishra <mrsud94@gmail.com>
+Anurag Sharma <anurags92@gmail.com>
+Soumya Dipta Biswas <sdb1323@gmail.com>
+Sushant Hiray <hiraysushant@gmail.com>
+Ben Lucato <ben.lucato@gmail.com>
+Kunal Arora <kunalarora.135@gmail.com>
+Henry Gebhardt <hsggebhardt@gmail.com>
+Dammina Sahabandu <dmsahabandu@gmail.com>
+Manish Shukla <manish.shukla393@gmail>
+Ralph Bean <rbean@redhat.com>
+richierichrawr <richierichrawr@users.noreply.github.com>
+John Connor <john.theman.connor@gmail.com>
+Juan Luis Cano Rodríguez <juanlu001@gmail.com>
+Sahil Shekhawat <sahilshekhawat01@gmail.com>
+Kundan Kumar <kundankumar18581@gmail.com>
+Stas Kelvich <stanconn@gmail.com>
+sevaader <sevaader@gmail.com>
+Dhruvesh Vijay Parikh <parikhdhruvesh1@gmail.com>
+Venkatesh Halli <venkatesh.fatality@gmail.com>
+Lennart Fricke <lennart@die-frickes.eu>
+Vlad Seghete <vlad.seghete@gmail.com>
+Shashank Agarwal <shashank.agarwal94@gmail.com>
+carstimon <carstimon@gmail.com>
+Pierre Haessig <pierre.haessig@crans.org>
+Maciej Baranski <getrox.sc@gmail.com>
+Benjamin Gudehus <hastebrot@gmail.com>
+Faisal Anees <faisal.iiit@gmail.com>
+Mark Shoulson <mark@kli.org>
+Robert Johansson <jrjohansson@gmail.com>
+Kalevi Suominen <jksuom@gmail.com>
+Kaushik Varanasi <kaushik.varanasi1@gmail.com>
+Fawaz Alazemi <Mba7eth@gmail.com>
+Ambar Mehrotra <mehrotraambar@gmail.com>
+David P. Sanders <dpsanders@gmail.com>
+Peter Brady <petertbrady@gmail.com>
+John V. Siratt <jvsiratt@gmail.com>
+Sarwar Chahal <chahal.sarwar98@gmail.com>
+Nathan Woods <charlesnwoods@gmail.com>
+Colin B. Macdonald <cbm@m.fsf.org>
+Marcus Näslund <naslundx@gmail.com>
+Clemens Novak <clemens@familie-novak.net>
+Mridul Seth <seth.mridul@gmail.com>
+Craig A. Stoudt <craig.stoudt@gmail.com>
+Raj <raj454raj@gmail.com>
+Mihai A. Ionescu <ionescu.a.mihai@gmail.com>
+immerrr <immerrr@gmail.com>
+Chai Wah Wu <cwwuieee@gmail.com>
+Leonid Blouvshtein <leonidbl91@gmail.com>
+Peleg Michaeli <freepeleg@gmail.com>
+ck Lux <lux.r.ck@gmail.com>
+zsc347 <zsc347@gmail.com>
+Hamish Dickson <hamish.dickson@gmail.com>
+Michael Gallaspy <gallaspy.michael@gmail.com>
+Roman Inflianskas <infroma@gmail.com>
+Duane Nykamp <nykamp@umn.edu>
+Ted Dokos <tdokos@gmail.com>
+Sunny Aggarwal <sunnyaggarwal1994@gmail.com>
+Victor Brebenar <v.brebenar@gmail.com>
+Akshat Jain <akshat.jain@students.iiit.ac.in>
+Shivam Vats <shivamvats.iitkgp@gmail.com>
+Longqi Wang <iqgnol@gmail.com>
+Juan Felipe Osorio <jfosorio@gmail.com>
+Ray Cathcart <github@cathcart.us>
+Lukas Zorich <lukas.zorich@gmail.com>
+Eric Miller <emiller42@gmail.com>
+Cody Herbst <cyherbst@gmail.com>
+Nishith Shah <nishithshah.2211@gmail.com>
+Amit Kumar <dtu.amit@gmail.com>
+Yury G. Kudryashov <urkud.urkud@gmail.com>
+Guillaume Gay <contact@damcb.com>
+Mihir Wadwekar <m.mihirw@gmail.com>
+Tuan Manh Lai <laituan245@gmail.com>
+Asish Panda <asishrocks95@gmail.com>
+Darshan Chaudhary <deathbullet@gmail.com>
+Alec Kalinin <alec.kalinin@gmail.com>
+Ralf Stephan <ralf@ark.in-berlin.de>
+Aaditya Nair <aadityanair6494@gmail.com>
+Jayesh Lahori <jlahori92@gmail.com>
+Harshil Goel <harshil158@gmail.com>
+Luv Agarwal <agarwal.iiit@gmail.com>
+Jason Ly <jason.ly@gmail.com>
+Lokesh Sharma <lokeshhsharma@gmail.com>
+Sartaj Singh <singhsartaj94@gmail.com>
+Chris Swierczewski <cswiercz@gmail.com>
+Konstantin Togoi <konstantin.togoi@gmail.com>
+Param Singh <paramsingh258@gmail.com>
+Sumith Kulal <sumith1896@gmail.com>
+Juha Remes <jremes@outlook.com>
+Philippe Bouafia <philippe.bouafia@ensea.fr>
+Peter Schmidt <peter@peterjs.com>
+Jiaxing Liang <liangjiaxing57@gmail.com>
+Lucas Jones <lucas@lucasjones.co.uk>
+Gregory Ashton <gash789@gmail.com>
+Jennifer White <jcrw122@googlemail.com>
+Renato Orsino <renato.orsino@gmail.com>
+Alistair Lynn <arplynn@gmail.com>
+Govind Sahai <gsiitbhu@gmail.com>
+Adam Bloomston <adam@glitterfram.es>
+Kyle McDaniel <mcdanie5@illinois.edu>
+Nguyen Truong Duy <truongduy134@yahoo.com>
+Alex Lindsay <adlinds3@ncsu.edu>
+Mathew Chong <mathewchong.dev@gmail.com>
+Jason Siefken <siefkenj@gmail.com>
+Gaurav Dhingra <gauravdhingra.gxyd@gmail.com>
+Gao, Xiang <qasdfgtyuiop@gmail.com>
+Kevin Ventullo <kevin.ventullo@gmail.com>
+mao8 <thisisma08@gmail.com>
+Isuru Fernando <isuruf@gmail.com>
+Shivam Tyagi <shivam.tyagi.apm13@itbhu.ac.in>
+Richard Otis <richard.otis@outlook.com>
+Rich LaSota <rjlasota@gmail.com>
+dustyrockpyle <dustyrockpyle@gmail.com>
+Anton Akhmerov <anton.akhmerov@gmail.com>
+Michael Zingale <michael.zingale@stonybrook.edu>
+Chak-Pong Chung <chakpongchung@gmail.com>
+David T <derDavidT@users.noreply.github.com>
+Phil Ruffwind <rf@rufflewind.com>
+Sebastian Koslowski <koslowski@kit.edu>
+Kumar Krishna Agrawal <kumar.1994.14@gmail.com>
+Dustin Gadal <Dustin.Gadal@gmail.com>
+João Moura <operte@gmail.com>
+Yu Kobayashi <yukoba@accelart.jp>
+Shashank Kumar <shashank.kumar.apc13@iitbhu.ac.in>
+Timothy Cyrus <tcyrus@users.noreply.github.com>
+Devyani Kota <devyanikota@gmail.com>
+Keval Shah <kevalshah_96@yahoo.co.in>
+Dzhelil Rufat <drufat@caltech.edu>
+Pastafarianist <mr.pastafarianist@gmail.com>
+Sourav Singh <souravsingh@users.noreply.github.com>
+Jacob Garber <jgarber1@ualberta.ca>
+Vinay Singh <csvinay.d@gmail.com>
+GolimarOurHero <metalera94@hotmail.com>
+Prashant Tyagi <prashanttyagi221295@gmail.com>
+Matthew Davis <davisml.md@gmail.com>
+Tschijnmo TSCHAU <tschijnmotschau@gmail.com>
+Alexander Bentkamp <bentkamp@gmail.com>
+Jack Kemp <metaknightdrake-git@yahoo.co.uk>
+Kshitij Saraogi <KshitijSaraogi@gmail.com>
+Thomas Baruchel <baruchel@gmx.com>
+Nicolás Guarín-Zapata <nicoguarin@gmail.com>
+Jens Jørgen Mortensen <jj@smoerhul.dk>
+Sampad Kumar Saha <sampadsaha5@gmail.com>
+Eva Charlotte Mayer <eva-charlotte.mayer@posteo.de>
+Laura Domine <temigo@gmx.com>
+Justin Blythe <jblythe29@gmail.com>
+Meghana Madhyastha <meghana.madhyastha@gmail.com>
+Tanu Hari Dixit <tokencolour@gmail.com>
+Shekhar Prasad Rajak <shekharrajak@live.com>
+Aqnouch Mohammed <aqnouch.mohammed@gmail.com>
+Arafat Dad Khan <arafat.da.khan@gmail.com>
+Boris Atamanovskiy <shaomoron@gmail.com>
+Sam Tygier <sam.tygier@hep.manchester.ac.uk>
+Jai Luthra <me@jailuthra.in>
+Guo Xingjian <Seeker1995@gmail.com>
+Sandeep Veethu <sandeep.veethu@gmail.com>
+Archit Verma <architv07@gmail.com>
+Shubham Tibra <shubh.tibra@gmail.com>
+Ashutosh Saboo <ashutosh.saboo96@gmail.com>
+Michael S. Hansen <michael.hansen@nih.gov>
+Anish Shah <shah.anish07@gmail.com>
+Guillaume Jacquenot <guillaume.jacquenot@gmail.com>
+Bhautik Mavani <mavanibhautik@gmail.com>
+Michał Radwański <enedil.isildur@gmail.com>
+Jerry Li <jerry@jerryli.ca>
+Pablo Zubieta <pabloferz@yahoo.com.mx>
+Shivam Agarwal <knowthyself2503@gmail.com>
+Chaitanya Sai Alaparthi <achaitanyasai@gmail.com>
+Arihant Parsoya <parsoyaarihant@gmail.com>
+Ruslan Pisarev <rpisarev@cloudlinux.com>
+Akash Trehan <akash.trehan123@gmail.com>
+Nishant Nikhil <nishantiam@gmail.com>
+Vladimir Poluhsin <vovapolu@gmail.com>
+Akshay Nagar <awesomeay13@yahoo.com>
+James Brandon Milam <jmilam343@gmail.com>
+Abhinav Agarwal <abhinavagarwal1996@gmail.com>
+Rishabh Daal <rishabhdaal@gmail.com>
+Sanya Khurana <sanya@monica.in>
+Aman Deep <amandeep1024@gmail.com>
+Aravind Reddy <aravindreddy255@gmail.com>
+Abhishek Verma <iamvermaabhishek@gmail.com>
+Matthew Parnell <matt@parnmatt.co.uk>
+Thomas Hickman <Thomas.Hickman42@gmail.com>
+Akshay Siramdas <akshaysiramdas@gmail.com>
+YiDing Jiang <yidinggjiangg@gmail.com>
+Jatin Yadav <jatinyadav25@gmail.com>
+Matthew Thomas <mnmt@users.noreply.github.com>
+Rehas Sachdeva <aquannie@gmail.com>
+Michael Mueller <michaeldmueller7@gmail.com>
+Srajan Garg <srajan.garg@gmail.com>
+Prabhjot Singh <prabhjot.nith@gmail.com>
+Haruki Moriguchi <harukimoriguchi@gmail.com>
+Tom Gijselinck <tomgijselinck@gmail.com>
+Nitin Chaudhary <nitinmax1000@gmail.com>
+Alex Argunov <sajkoooo@gmail.com>
+Nathan Musoke <nathan.musoke@gmail.com>
+Abhishek Garg <abhishekgarg119@gmail.com>
+Dana Jacobsen <dana@acm.org>
+Vasiliy Dommes <vasdommes@gmail.com>
+Phillip Berndt <phillip.berndt@googlemail.com>
+Haimo Zhang <zh.hammer.dev@gmail.com>
+Anthony Scopatz <scopatz@gmail.com>
+bluebrook <perl4logic@gmail.com>
+Leonid Kovalev <leonidvkovalev@gmail.com>
+Josh Burkart <jburkart@gmail.com>
+Dimitra Konomi <t8130064@dias.aueb.gr>
+Christina Zografou <t8130048@dias.aueb.gr>
+Fiach Antaw <fiach.antaw+github@gmail.com>
+Langston Barrett <langston.barrett@gmail.com>
+Krit Karan <kritkaran.b13@iiits.in>
+G. D. McBain <gdmcbain@protonmail.com>
+Prempal Singh <prempal.42@gmail.com>
+Gabriel Orisaka <orisaka@gmail.com>
+Matthias Bussonnier <bussonniermatthias@gmail.com>
+rahuldan <rahul02013@gmail.com>
+Colin Marquardt <github@marquardt-home.de>
+Andrew Taber <andrew.e.taber@gmail.com>
+Yash Reddy <write2yashreddy@gmail.com>
+Peter Stangl <peter.stangl@ph.tum.de>
+elvis-sik <e.sikora@grad.ufsc.br>
+Nikos Karagiannakis <nikoskaragiannakis@gmail.com>
+Jainul Vaghasia <jainulvaghasia@gmail.com>
+Dennis Meckel <meckel@datenschuppen.de>
+Harshil Meena <harshil.7535@gmail.com>
+Micky <mickydroch@gmail.com>
+Nick Curtis <nicholas.curtis@uconn.edu>
+Michele Zaffalon <michele.zaffalon@gmail.com>
+Martha Giannoudovardi <maapxa@gmail.com>
+Devang Kulshreshtha <devang.kulshreshtha.cse14@itbhu.ac.in>
+Steph Papanik <spapanik21@gmail.com>
+Mohammad Sadeq Dousti <msdousti@gmail.com>
+Arif Ahmed <arif.ahmed.5.10.1995@gmail.com>
+Abdullah Javed Nesar <abduljaved1994@gmail.com>
+Lakshya Agrawal <zeeshan.lakshya@gmail.com>
+shruti <shrutishrm512@gmail.com>
+Rohit Rango <rohit.rango@gmail.com>
+Hong Xu <hong@topbug.net>
+Ivan Petuhov <ivan@ostrovok.ru>
+Alsheh <alsheh@rpi.edu>
+Marcel Stimberg <marcel.stimberg@ens.fr>
+Alexey Pakhocmhik <cool.Bakov@yandex.ru>
+Tommy Olofsson <tommy.olofsson.90@gmail.com>
+Zulfikar <zulfikar97@gmail.com>
+Blair Azzopardi <blairuk@gmail.com>
+Danny Hermes <daniel.j.hermes@gmail.com>
+Sergey Pestov <pestov-sa@yandex.ru>
+Mohit Chandra <mohit.chandra@research.iiit.ac.in>
+Karthik Chintapalli <karthik.chintapalli@students.iiit.ac.in>
+Marcin Briański <marcin.brianski@student.uj.edu.pl>
+andreo <andrey.torba@gmail.com>
+Flamy Owl <flamyowl@protonmail.ch>
+Yicong Guo <guoyicong100@gmail.com>
+Varun Garg <varun.garg03@gmail.com>
+Rishabh Madan <rishabhmadan96@gmail.com>
+Aditya Kapoor <aditya.kapoor.apm12@itbhu.ac.in>
+Karan Sharma <karan1276@gmail.com>
+Vedant Rathore <vedantr1998@gmail.com>
+Johan Blåbäck <johan_bluecreek@riseup.net>
+Pranjal Tale <pranjaltale16@gmail.com>
+Jason Tokayer <jason.tokayer@gmail.com>
+Raghav Jajodia <jajodia.raghav@gmail.com>
+Rajat Thakur <rajatthakur1997@gmail.com>
+Dhruv Bhanushali <dhruv_b@live.com>
+Anjul Kumar Tyagi <anjul.ten@gmail.com>
+Barun Parruck <barun.parruck@gmail.com>
+Bao Chau <chauquocbao0907@gmail.com>
+Tanay Agrawal <tanay_agrawal@hotmail.com>
+Ranjith Kumar <ranjith.dakshana2015@gmail.com>
+Shikhar Makhija <shikharmakhija2@gmail.com>
+Yathartha Joshi <yathartha32@gmail.com>
+Valeriia Gladkova <valeriia.gladkova@gmail.com>
+Sagar Bharadwaj <sagarbharadwaj50@gmail.com>
+Daniel Mahler <dmahler@gmail.com>
+Ka Yi <chua.kayi@yahoo.com.sg>
+Rishat Iskhakov <iskhakov@frtk.ru>
+Szymon Mieszczak <szymon.mieszczak@gmail.com>
+Sachin Agarwal <sachinagarwal0499@gmail.com>
+Priyank Patel <pspbot7@gmail.com>
+Satya Prakash Dwibedi <akash581050@gmail.com>
+tools4origins <tools4origins@gmail.com>
+Nico Schlömer <nico.schloemer@gmail.com>
+Fermi Paradox <FermiParadox@users.noreply.github.com>
+Ekansh Purohit <purohit.e15@gmail.com>
+Vedarth Sharma <vedarth.sharma@gmail.com>
+Peeyush Kushwaha <peeyush.p97@gmail.com>
+Jayjayyy <vfhsln8s3l4b87t4c3@byom.de>
+Christopher J. Wright <cjwright4242gh@gmail.com>
+Jakub Wilk <jwilk@jwilk.net>
+Mauro Garavello <mauro.garavello@unimib.it>
+Chris Tefer <ctefer@gmail.com>
+Shikhar Jaiswal <jaiswalshikhar87@gmail.com>
+Chiu-Hsiang Hsu <wdv4758h@gmail.com>
+Carlos Cordoba <ccordoba12@gmail.com>
+Fabian Ball <fabian.ball@kit.edu>
+Yerniyaz <yerniyaz.nurgabylov@nu.edu.kz>
+Christiano Anderson <canderson@riseup.net>
+Robin Neatherway <robin.neatherway@gmail.com>
+Thomas Hunt <thomashunt13@gmail.com>
+Theodore Han <theodorehan@hotmail.com>
+Duc-Minh Phan <alephvn@gmail.com>
+Lejla Metohajrova <l.metohajrova@gmail.com>
+Samyak Jain <samyak.jain2016a@vitstudent.ac.in>
+Aditya Rohan <riyuzakiiitk@gmail.com>
+Vincent Delecroix <vincent.delecroix@labri.fr>
+Michael Sparapany <msparapa@purdue.edu>
+Harsh Jain <harshjniitr@gmail.com>
+Nathan Goldbaum <ngoldbau@illinois.edu>
+latot <felipematas@yahoo.com>
+Kenneth Lyons <ixjlyons@gmail.com>
+Stan Schymanski <stan.schymanski@env.ethz.ch>
+David Daly <david.daly12@kzoo.edu>
+Ayush Shridhar <ayush.shridhar1999@gmail.com>
+Javed Nissar <javednissar@gmail.com>
+Jiri Kuncar <jiri.kuncar@gmail.com>
+vedantc98 <vedantc98@gmail.com>
+Rupesh Harode <rupeshharode@gmail.com>
+Rob Zinkov <rob@zinkov.com>
+James Harrop <ebc121@gmail.com>
+James Taylor <user234683@tutanota.com>
+Ishan Joshi <ishanaj98@gmail.com>
+Marco Mancini <marco.mancini@obspm.fr>
+Boris Ettinger <ettinger.boris@gmail.com>
+Micah Fitch <micahscopes@gmail.com>
+Daniel Wennberg <daniel.wennberg@gmail.com>
+ylemkimon <ylemkimon@naver.com>
+Akash Vaish <akash.9712@gmail.com>
+Peter Enenkel <peter.enenkel+git@gmail.com>
+Waldir Pimenta <waldyrious@gmail.com>
+Jithin D. George <jithindgeorge93@gmail.com>
+Lev Chelyadinov <leva181777@gmail.com>
+Lucas Wiman <lucas.wiman@gmail.com>
+Rhea Parekh <rheaparekh12@gmail.com>
+James Cotton <peabody124@gmail.com>
+Robert Pollak <robert.pollak@posteo.net>
+anca-mc <anca-mc@users.noreply.github.com>
+Sourav Ghosh <souravghosh2197@gmail.com>
+Jonathan Allan <jjallan@users.noreply.github.com>
+Nikhil Pappu <nkhlpappu@gmail.com>
+Ethan Ward <etkewa@gmail.com>
+Cezary Marczak <zeddq1@gmail.com>
+dps7ud <dps7ud@virginia.edu>
+Nilabja Bhattacharya <nilabja10201992@gmail.com>
+Itay4 <31018228+Itay4@users.noreply.github.com>
+Poom Chiarawongse <eight1911@gmail.com>
+Yang Yang <wdscxsj@gmail.com>
+Cavendish McKay <cmckay@tachycline.com>
+Bradley Gannon <bradley.m.gannon@gmail.com>
+B McG <bmcg0890@gmail.com>
+Rob Drynkin <rob.drynkin@gmail.com>
+Seth Ebner <murgrehk@gmail.com>
+Akash Kundu <sk.sayakkundu1997@gmail.com>
+Mark Jeromin <mark.jeromin@sysfrog.net>
+Roberto Díaz Pérez <r.r.1994a@gmail.com>
+Gleb Siroki <g.shiroki@gmail.com>
+Segev Finer <segev208@gmail.com>
+Alex Lubbock <code@alexlubbock.com>
+Ayodeji Ige <ayodeji18@outlook.com>
+Matthew Wardrop <matthew.wardrop@airbnb.com>
+Hugo van Kemenade <hugovk@users.noreply.github.com>
+Austin Palmer <ap4000@nyu.edu>
+der-blaue-elefant <github@kklein.de>
+Filip Gokstorp <filip@gokstorp.se>
+Yuki Matsuda <yuki.matsuda.w@gmail.com>
+Aaron Miller <acmiller273@gmail.com>
+Salil Vishnu Kapur <salilvishnukapur@gmail.com>
+Atharva Khare <khareatharva@gmail.com>
+Shubham Maheshwari <rmaheshwari05@gmail.com>
+Pavel Tkachenko <paveltkachenko@email.com>
+Ashish Kumar Gaurav <ashishkg0022@gmail.com>
+Rajeev Singh <rajs2010@gmail.com>
+Keno Goertz <keno@goertz-berlin.com>
+Lucas Gallindo <lgallindo@gmail.com>
+Himanshu <hs80941@gmail.com>
+David Menéndez Hurtado <david.menendez.hurtado@scilifelab.se>
+Amit Manchanda <amitdelhi1995@gmail.com>
+Rohit Jain <rohitjain3241@gmail.com>
+Jonathan A. Gross <jarthurgross@gmail.com>
+Unknown <kunda@scribus.net>
+Sayan Goswami <Sayan98@users.noreply.github.com>
+Subhash Saurabh <subhashsaurabh419@gmail.com>
+Rastislav Rabatin <rastislav.rabatin@gmail.com>
+Vishal <vishalg2235@gmail.com>
+Jeremey Gluck <jeremygluck@yahoo.com>
+Akshat Maheshwari <akshat14714@gmail.com>
+symbolique <symbolique@users.noreply.github.com>
+Saloni Jain <tosalonijain@gmail.com>
+Arighna Chakrabarty <arighna.chakrabarty100@gmail.com>
+Abhigyan Khaund <mail@abhigyan.xyz>
+Jashanpreet Singh <jashansingh.4398@gmail.com>
+Saurabh Agarwal <shourabh.agarwal@gmail.com>
+luzpaz <luzpaz@users.noreply.github.com>
+P. Sai Prasanth <psai.prasanth.min16@itbhu.ac.in>
+Nirmal Sarswat <nirmalsarswat400@gmail.com>
+Cristian Di Pietrantonio <cristiandipietrantonio@gmail.com>
+Ravi charan <ravicharan.vsp@gmail.com>
+Nityananda Gohain <nityanandagohain@gmail.com>
+Cédric Travelletti <cedrictravelletti@gmail.com>
+Nicholas Bollweg <nick.bollweg@gmail.com>
+Himanshu Ladia <hladia199811@gmail.com>
+Adwait Baokar <adwaitbaokar18@gmail.com>
+Mihail Tarigradschi <m.tarigradschi@gmail.com>
+Saketh <alurusaisaketh@gmail.com>
+rushyam <rushyamsonu@gmail.com>
+sfoo <sfoohei@gmail.com>
+Rahil Hastu <rahilhastu@gmail.com>
+Zach Raines <raineszm@gmail.com>
+Sidhant Nagpal <sidhantnagpal97@gmail.com>
+Gagandeep Singh <singh.23@iitj.ac.in>
+Rishav Chakraborty <annonymousxyz@outlook.com>
+Malkhan Singh <malkhansinghrathaur@gmail.com>
+Joaquim Monserrat <qmonserrat@mailoo.org>
+Mayank Singh <mayank.singh081997@gmail.com>
+Rémy Léone <rleone@online.net>
+Maxence Mayrand <35958639+maxencemayrand@users.noreply.github.com>
+Nikoleta Glynatsi <GlynatsiNE@cardiff.ac.uk>
+helo9 <helo9@users.noreply.github.com>
+Ken Wakita <wakita@is.titech.ac.jp>
+Carl Sandrock <carl.sandrock@up.ac.za>
+Fredrik Eriksson <freeriks@student.chalmers.se>
+Ian Swire <oversizedpenguin@gmail.com>
+Bulat <daianovich@mail.ru>
+Ehren Metcalfe <ehren.m@gmail.com>
+Dmitry Savransky <dsavransky@gmail.com>
+Kiyohito Yamazaki <kyamaz@openql.org>
+Caley Finn <caleyreuben@gmail.com>
+Zhi-Qiang Zhou <zzq_890709@hotmail.com>
+Alexander Pozdneev <pozdneev@users.noreply.github.com>
+Wes Turner <50891+westurner@users.noreply.github.com>
+JMSS-Unknown <31131631+JMSS-Unknown@users.noreply.github.com>
+Arshdeep Singh <singh.arshdeep1999@gmail.com>
+cym1 <16437732+cym1@users.noreply.github.com>
+Stewart Wadsworth <stewart.wadsworth@gmail.com>
+Jared Lumpe <mjlumpe@gmail.com>
+Avi Shrivastava <shrivastavaavi123@gmail.com>
+ramvenkat98 <ramvenkat98@gmail.com>
+Bilal Ahmed <b.ahmed0918@gmail.com>
+Dimas Abreu Archanjo Dutra <dimasad@ufmg.br>
+Yatna Verma <yatnavermaa@gmail.com>
+S.Y. Lee <sylee957@gmail.com>
+Miro Hrončok <miro@hroncok.cz>
+Sudarshan Kamath <sudarshan.kamath97@gmail.com>
+Ayushman Koul <ayushmankoul4570@gmail.com>
+Robert Dougherty-Bliss <robert.w.bliss@gmail.com>
+Andrey Grozin <A.G.Grozin@inp.nsk.su>
+Bavish Kulur <bavishkulur@gmail.com>
+Arun Singh <arunsin997@gmail.com>
+sirnicolaf <43586954+sirnicolaf@users.noreply.github.com>
+Zachariah Etienne <zachetie@gmail.com>
+Prayush Dawda <35144226+iamprayush@users.noreply.github.com>
+2torus <boris.ettinger@gmail.com>
+Faisal Riyaz <faisalriyaz011@gmail.com>
+Martin Roelfs <u0114255@kuleuven.be>
+SirJohnFranklin <sirjfu@googlemail.com>
+Anthony Sottile <asottile@umich.edu>
+ViacheslavP <public.viacheslav@gmail.com>
+Safiya03 <safiyanesar@gmail.com>
+Alexander Dunlap <alexander.dunlap@gmail.com>
+Rohit Sharma <31184621+rohitx007@users.noreply.github.com>
+Jonathan Warner <warnerjon12@gmail.com>
+Mohit Balwani <mohitbalwani.ict17@gmail.com>
+Marduk Bolaños <mardukbp@mac.com>
+amsuhane <ayushsuhane99@iitkgp.ac.in>
+Matthias Geier <Matthias.Geier@gmail.com>
+klaasvanaarsen <44929042+klaasvanaarsen@users.noreply.github.com>
+Shubham Kumar Jha <skjha832@gmail.com>
+rationa-kunal <kunalgk1999@gmail.com>
+Animesh Sinha <animeshsinha1309@gmail.com>
+Gaurang Tandon <1gaurangtandon@gmail.com>
+Matthew Craven <clyring@users.noreply.github.com>
+Daniel Ingram <ingramds@appstate.edu>
+Jogi Miglani <jmig5776@gmail.com>
+Takumasa Nakamura <n.takumasa@gmail.com>
+Ritu Raj Singh <RituRajSingh878@gmail.com>
+Rajiv Ranjan Singh <rajivperfect007@gmail.com>
+Vera Lozhkina <veralozhkina@gmail.com>
+adhoc-king <46354827+adhoc-king@users.noreply.github.com>
+Mikel Rouco <mikel.mrm@gmail.com>
+Oscar Gustafsson <oscar.gustafsson@gmail.com>
+damianos <damianos@semmle.com>
+Supreet Agrawal <supreet11agrawal@gmail.com>
+shiksha11 <shiksharawat01@gmail.com>
+Martin Ueding <dev@martin-ueding.de>
+sharma-kunal <kunalsharma6914@gmail.com>
+Divyanshu Thakur <divyanshu@iiitmanipur.ac.in>
+Susumu Ishizuka <susumu.ishizuka@kii.com>
+Samnan Rahee <namanush.rsr.16@gmail.com>
+Fredrik Andersson <fredrik.andersson@fcc.chalmers.se>
+Bhavya Srivastava <bhavya17037@iiitd.ac.in>
+Alpesh Jamgade <alpeshjamgade21@gmail.com>
+Shubham Abhang <shubhamabhang77@gmail.com>
+Vishesh Mangla <manglavishesh64@gmail.com>
+Nicko van Someren <nicko@nicko.org>
+dandiez <47832466+dandiez@users.noreply.github.com>
+Frédéric Chapoton <fchapoton2@gmail.com>
+jhanwar <f2015463@pilani.bits-pilani.ac.in>
+Noumbissi valere Gille Geovan <noumbissivalere@gmail.com>
+Salmista-94 <alejandrogroso@hotmail.com>
+Shivani Kohli <shivanikohli.09@gmail.com>
+Parker Berry <parkereberry@gmail.com>
+Pragyan Mehrotra <pragyan18168@iiitd.ac.in>
+Nabanita Dash <dashnabanita@gmail.com>
+Gaetano Guerriero <x.guerriero@tin.it>
+Ankit Raj Pandey <pandeyan@grinnell.edu>
+Ritesh Kumar <ritesh99rakesh@gmail.com>
+kangzhiq <709563092@qq.com>
+Jun Lin <junlin0604@gmail.com>
+Petr Kungurtsev <corwinat@gmail.com>
+Anway De <anway1756@gmail.com>
+znxftw <vishnu2101@gmail.com>
+Denis Ivanenko <ivanenko@ucu.edu.ua>
+Orestis Vaggelis <orestisvaggelis@mail.com>
+Nikhil Maan <nikhilmaan22@gmail.com>
+Abhinav Anand <abhinav.anand2807@gmail.com>
+Qingsha Shi <googol.sqs@gmail.com>
+Juan Barbosa <js.barbosa10@uniandes.edu.co>
+Prionti Nasir <pdn3628@rit.edu>
+Bharat Raghunathan <bharatraghunthan9767@gmail.com>
+arooshiverma <av22@iitbbs.ac.in>
+Christoph Gohle <ctg@mpq.mpg.de>
+Charalampos Tsiagkalis <ctsiagkalis@uth.gr>
+Daniel Sears <highpost@users.noreply.github.com>
+Megan Ly <megan.ly@learnosity.com>
+Sean P. Cornelius <spcornelius@gmail.com>
+Erik R. Gomez <gomez@kth.se>
+Riccardo Magliocchetti <riccardo.magliocchetti@gmail.com>
+Henry Metlov <genrih.metlov@gmail.com>
+pekochun <hamburg_hamburger2000@yahoo.co.jp>
+Bendik Samseth <b.samseth@gmail.com>
+Vighnesh Shenoy <vighneshq@gmail.com>
+Versus Void <versusvoid@gmail.com>
+Denys Rybalka <rybalka.denis@gmail.com>
+Mark Dickinson <dickinsm@gmail.com>
+Rimi <rimibis@umich.edu>
+rimibis <33387803+rimibis@users.noreply.github.com>
+Steven Lee <stevenlee123@protonmail.com>
+Gilles Schintgen <gschintgen@hambier.lu>
+Abhi58 <abhijithbharadwaj58@gmail.com>
+Tomasz Pytel <tompytel@gmail.com>
+Aadit Kamat <aadit.k12@gmail.com>
+Samesh <samesh.lakhotia@gmail.com>
+Velibor Zeli <velibor@mech.kth.se>
+Gabriel Bernardino <gabriel.bernardino@upf.edu>
+Joseph Redfern <joseph@redfern.me>
+Evelyn King <evelyn.cameron.king@gmail.com>
+Miguel Marco <mmarco@unizar.es>
+David Hagen <david@drhagen.com>
+Hannah Kari <hannah.kari@marquette.edu>
+Soniya Nayak <soniyanayak51@gmail.com>
+Harsh Agarwal <hagarwal9200@gmail.com>
+Enric Florit <efz1005@gmail.com>
+Yogesh Mishra <ymishra013@gmail.com>
+Denis Rykov <rykovd@gmail.com>
+Ivan Tkachenko <me@ratijas.tk>
+Kenneth Emeka Odoh <kenneth.odoh@gmail.com>
+Stephan Seitz <stephan.seitz@fau.de>
+Yeshwanth N <yeshsurya@gmail.com>
+Oscar Gerardo Lazo Arjona <oscar.lazoarjona@physics.ox.ac.uk>
+Srinivasa Arun Yeragudipati <ysarun1999@gmail.com>
+Kirtan Mali <kirtanmali555@gmail.com>
+TitanSnow <sweeto@live.cn>
+Pengning Chao <8857165+PengningChao@users.noreply.github.com>
+Louis Abraham <louis.abraham@yahoo.fr>
+Morten Olsen Lysgaard <morten@lysgaard.no>
+Akash Nagaraj (akasnaga) <akasnaga@cisco.com>
+Akash Nagaraj <grassknoted@gmail.com>
+Lauren Glattly <laurenglattly@gmail.com>
+Hou-Rui <houruinus@gmail.com>
+George Korepanov <gkorepanov.gk@gmail.com>
+dranknight09 <cbhaavan@gmail.com>
+aditisingh2362 <aditisingh2362@gmail.com>
+Gina <Dr-G@users.noreply.github.com>
+gregmedlock <gmedlo@gmail.com>
+Georgios Giapitzakis Tzintanos <giorgosgiapis@mail.com>
+Eric Wieser <wieser.eric@gmail.com>
+Bradley Dowling <34559056+btdow@users.noreply.github.com>
+Maria Marginean <33810762+mmargin@users.noreply.github.com>
+Akash Agrawall <akash.wanted@gmail.com>
+jgulian <josephdgulian@gmail.com>
+Sourav Goyal <souravgl0@gmail.com>
+Zlatan Vasović <zlatanvasovic@gmail.com>
+Alex Meiburg <timeroot.alex@gmail.com>
+Smit Lunagariya <smitlunagariya.mat18@itbhu.ac.in>
+Naman Gera <namangera15@gmail.com>
+Julien Palard <julien@palard.fr>
+Dhruv Mendiratta <dhruvmendiratta6@gmail.com>
+erdOne <36414270+erdOne@users.noreply.github.com>
+risubaba <risubhjain1010@gmail.com>
+abhinav28071999 <41710346+abhinav28071999@users.noreply.github.com>
+Jisoo Song <jeesoo9595@snu.ac.kr>
+Jaime R <38530589+Jaime02@users.noreply.github.com>
+Vikrant Malik <vikrantmalik051@gmail.com>
+Hardik Saini <43683678+Guardianofgotham@users.noreply.github.com>
+Abhishek <uchiha@pop-os.localdomain>
+Johannes Hartung <joha2@gmx.net>
+Milan Jolly <milan.cs16@iitp.ac.in>
+faizan2700 <syedfaizan824@gmail.com>
+mohit <39158356+mohitacecode@users.noreply.github.com>
+Mohit Gupta <mohitgupta@gmail.com>
+Psycho-Pirate <prakharsaxena.civ18@iitbhu.ac.in>
+Chanakya-Ekbote <ca10@iitbbs.ac.in>
+Rashmi Shehana <rashmi.watagedara@syscolabs.com>
+Jonty16117 <jonty@DESKTOP-J1O6ANP.localdomain>
+Anubhav Gupta <anubhav.gupta.cse19@itbhu.ac.in>
+Michal Grňo <m93a.cz@gmail.com>
+vezeli <37907135+vezeli@users.noreply.github.com>
+Tim Gates <tim.gates@iress.com>
+Sandeep Murthy <smurthy@protonmail.ch>
+Neil <mistersheik@gmail.com>
+V1krant <46847915+V1krant@users.noreply.github.com>
+alejandro <amartinhernan@gmail.com>
+Riyan Dhiman <Riyandhiman14@gmail.com>
+sbt4104 <sthorat661@gmail.com>
+Seth Troisi <sethtroisi@google.com>
+Bhaskar Gupta <guptabhanu1999@gmail.com>
+Smit Gajjar <smitgajjar.gs@gmail.com>
+rbl <rlee@grove.co>
+Ilya Pchelintsev <ilya.pchelintsev@outlook.com>
+Omar Wagih <o.wagih.ow@gmail.com>
+prshnt19 <prashant.rawat216@gmail.com>
+Johan Guzman <jguzm022@ucr.edu>
+Vasileios Kalos <kalosbasileios@gmail.com>
+BasileiosKal <61801875+BasileiosKal@users.noreply.github.com>
+Shubham Thorat <37049710+sbt4104@users.noreply.github.com>
+Arpan Chattopadhyay <f20180319@pilani.bits-pilani.ac.in>
+Ashutosh Hathidara <ashutoshhathidara98@gmail.com>
+Moses Paul R <iammosespaulr@gmail.com>
+Saanidhya vats <saanidhyavats@gmail.com>
+tnzl <you@example.com>
+Vatsal Srivastava <alstav.trivas.sava@gmail.com>
+Jean-Luc Herren <jlh@gmx.ch>
+Dhruv Kothari <dhruvkothari22@gmail.com>
+seadavis <45022599+seadavis@users.noreply.github.com>
+kamimura <kamimura@live.jp>
+slacker404 <pchantza@gmail.com>
+Jaime Resano <gemailpersonal02@gmail.com>
+Ebrahim Byagowi <ebrahim@gnu.org>
+wuyudi <wuyudi119@163.com>
+Akira Kyle <ak@akirakyle.com>
+Calvin Jay Ross <calvinjayross@gmail.com>
+Martin Thoma <info@martin-thoma.de>
+Thomas A Caswell <tcaswell@gmail.com>
+Lagaras Stelios <stel.lag@hotmail.com>
+Jerry James <loganjerry@gmail.com>
+Jan Kruse <janckruse@t-online.de>
+Nathan Taylor <pecan.pine@gmail.com>
+Vaishnav Damani <vaishnavdamani3496@gmail.com>
+Mohit Shah <mohitshah3111999@gmail.com>
+Mathias Louboutin <mathias.louboutin@gmail.com>
+Marijan Smetko <marijansmetko123@gmail.com>
+Dave Witte Morris <Dave.Morris@uleth.ca>
+soumi7 <soumibardhan10@gmail.com>
+Zhongshi <zj495@nyu.edu>
+Wes Galbraith <galbwe92@gmail.com>
+KaustubhDamania <kaustubh.damania@gmail.com>
+w495 <w495@yandex-team.ru>
+Akhil Rajput <akh1lrjput@gmail.com>
+Markus Mohrhard <markus.mohrhard@googlemail.com>
+Benjamin Wolba <mail@benjaminwolba.com>
+彭于斌 <1931127624@qq.com>
+Rudr Tiwari <rudrtiwari@gmail.com>
+Aaryan Dewan <aaryandewan@yahoo.com>
+Benedikt Placke <benedikt.placke@outlook.com>
+Sneha Goddu <s.goddu@wustl.edu>
+goddus <39923708+goddus@users.noreply.github.com>
+Shivang Dubey <shivangdubey8@gmail.com>
+Michael Greminger <michael.greminger@gmail.com>
+Peter Cock <p.j.a.cock@googlemail.com>
+Willem Melching <willem.melching@gmail.com>
+Elias Basler <e.e.basler@protonmail.com>
+Brandon David <brandon.david@zoho.com>
+Abhay_Dhiman <abhaysdhimans@gmail.com>
+Tasha Kim <jae_young_kim@brown.edu>
+Ayush Malik <ayushmalik779@gmail.com>
+Devesh Sawant <devesh47cool@gmail.com>
+Wolfgang Stöcher <wolfgang@stoecher.com>
+Sudeep Sidhu <sudeepmanilsidhu@gmail.com>
+foice <foice.news@gmail.com>
+Ben Payne <ben.is.located@gmail.com>
+Muskan Kumar <31043527+muskanvk@users.noreply.github.com>
+noam simcha finkelstein <noam.finkelstein@protonmail.com>
+Garrett Folbe <gmfolbe@yahoo.com>
+Islam Mansour <is3mansour@gmail.com>
+Sayandip Halder <sayandiph4@gmail.com>
+Shubham Agrawal <shubham.ag6845@gmail.com>
+numbermaniac <5206120+numbermaniac@users.noreply.github.com>
+Sakirul Alam <binarysakir@gmail.com>
+Mohammed Bilal <r.mohammedbilal@gmail.com>
+Chris du Plessis <christopherjonduplessis@gmail.com>
+Coder-RG <rgoel1999@gmail.com>
+Ansh Mishra <anshmishra471@gmail.com>
+Alex Malins <github@alexmalins.com>
+Lorenzo Contento <lorenzo.contento@gmail.com>
+Naveen Sai <naveensaisreenivas@gmail.com>
+Shital Mule <shitalmule04@gmail.com>
+Amanda Dsouza <meezamanda@yahoo.com>
+Nijso Beishuizen <nijso@koolmees.numerically-related.com>
+Harry Zheng <harry@harryzheng.com>
+Felix Yan <felixonmars@archlinux.org>
+Constantin Mateescu <costica1234@me.com>
+Eva Tiwari <eva.tiwari@gmail.com>
+Aditya Kumar Sinha <adityakumar113141@gmail.com>
+Soumi Bardhan <51290447+Soumi7@users.noreply.github.com>
+Kaustubh Chaudhari <ckaustubhm06@gmail.com>
+Kristian Brünn <hello@kristianbrunn.com>
+Neel Gorasiya <mgorasiya1974@gmail.com>
+Akshat Sood <68052998+akshatsood2249@users.noreply.github.com>
+Jose M. Gomez <chemoki@gmail.com>
+Stefan Petrea <stefan@garage-coding.com>
+Praveen Sahu <povinsahu@gmail.com>
+Mark Bell <mark00bell@googlemail.com>
+AlexCQY <alex_chua@u.nus.edu>
+Fabian Froehlich <fabian@schaluck.com>
+Nikhil Gopalam <gopalamn@umich.edu>
+Kartik Sethi <kartiks31416@gmail.com>
+Muhammed Abdul Quadir Owais <quadirowais200@gmail.com>
+Harshit Yadav <harshityadav2k@gmail.com>
+Sidharth Mundhra <sidharthmundhra16@gmail.com>
+Suryam Arnav Kalra <suryamkalra35@gmail.com>
+Prince Gupta <codemastercpp@gmail.com>
+Kunal Singh <ksingh19136@gmail.com>
+Mayank Raj <mayank_1901cs35@iitp.ac.in>
+Achal Jain <2achaljain@gmail.com>
+Mario Maio <mario.maio@aruba.it>
+Aaron Stiff <69512633+AaronStiff@users.noreply.github.com>
+Wyatt Peak <wyattpeak@gmail.com>
+Bhaskar Joshi <bhaskar.joshi@research.iiit.ac.in>
+Aditya Jindal <jaditya8889@gmail.com>
+Vaibhav Bhat <vaibhav.bhat2097@gmail.com>
+Priyansh Rathi <techiepriyansh@gmail.com>
+Saket Kumar Singh <saketkumar1202@gmail.com>
+Yukai Chou <muzimuzhi@gmail.com>
+Qijia Liu <liumeo@pku.edu.cn>
+Paul Mandel <paulmandel@google.com>
+Nisarg Chaudhari <54911392+Nisarg-Chaudhari@users.noreply.github.com>
+Dominik Stańczak <stanczakdominik@gmail.com>
+Rodrigo Luger <rodluger@gmail.com>
+Marco Antônio Habitzreuter <mahabitzreuter@gmail.com>
+Ayush Bisht <bisht.ayush2001@gmail.com>
+Akshansh Bhatt <akshansh@tuta.io>
+Brandon T. Willard <brandonwillard@users.noreply.github.com>
+Thomas Aarholt <thomasaarholt@gmail.com>
+Hiren Chalodiya <hirenchalodiya99@gmail.com>
+Roland Dixon <rols121@gmail.com>
+dimasvq <dimas.vq.2020@bristol.ac.uk>
+Sagar231 <sagarfeb298@gmail.com>
+Michael Chu <michael02chu@gmail.com>
+Abby Ng <abigailjng@gmail.com>
+Angad Sandhu <55819847+angadsinghsandhu@users.noreply.github.com>
+Alexander Cockburn <alexander_cockburn12@hotmail.com>
+Yaser AlOsh <yaseralosh@outlook.com>
+Davide Sandonà <sandona.davide@gmail.com>
+Jonathan Gutow <gutow@uwosh.edu>
+Nihir Agarwal <f20180701@pilani.bits-pilani.ac.in>
+Lee Johnston <lee.johnston.100@gmail.com>
+Zach Carmichael <20629897+craymichael@users.noreply.github.com>
+Vijairam Ganesh Moorthy <vijairamg@gmail.com>
+Hanspeter Schmid <hanspeter.schmid@fhnw.ch>
+Ben Oostendorp <oostben@umich.edu>
+Nikita <nikita.student.cse19@itbhu.ac.in>
+Aman <amanmourya295@gmail.com>
+Shashank KS <shashankks0987@gmail.com>
+Aman Sharma <amansharma110603@gmail.com>
+Anup Parikh <parikhanupk@gmail.com>
+Lucy Mountain <lucymountain1@icloud.com>
+Miguel Torres Costa <miguelptcosta1995@gmail.com>
+Rikard Nordgren <rikard.nordgren@farmaci.uu.se>
+Arun sanganal <74652697+ArunSanganal@users.noreply.github.com>
+Kamlesh Joshi <72374645+kamleshjoshi8102@users.noreply.github.com>
+Joseph Rance <56409230+Joseph-Rance@users.noreply.github.com>
+Huangduirong <huangduirong@huawei.com>
+Nils Schulte <47043622+Schnilz@users.noreply.github.com>
+Matt Bogosian <matt@bogosian.net>
+Elisha Hollander <just4now666666@gmail.com>
+Aditya Ravuri <infprobscix@gmail.com>
+Mamidi Ratna Praneeth <praneethratna@gmail.com>
+Jeffrey Ryan <jeffaryan7@gmail.com>
+Jonathan Daniel <36337649+jond01@users.noreply.github.com>
+Robin Richard <raisin@ecomail.fr>
+Gautam Menghani <gum3ng@protonmail.com>
+Remco de Boer <29308176+redeboer@users.noreply.github.com>
+Sebastian East <sebastianeast@ymail.com>
+Evani Balasubramanyam <balasubramanyam.evani@gmail.com>
+Rahil Parikh <r.parikh@somaiya.edu>
+Jason Ross <jasonross1024@gmail.com>
+Joannah Nanjekye <joannah.nanjekye@ibm.com>
+Ayush Kumar <ayushk7102@gmail.com>
+Kshitij <kshitijparwani.mat18@itbhu.ac.in>
+Daniel Hyams <dhyams@gmail.com>
+alijosephine <alijosephine@gmail.com>
+Matthias Köppe <mkoeppe@math.ucdavis.edu>
+mohajain <mohajain99@gmail.com>
+Anibal M. Medina-Mardones <ammedmar@gmail.com>
+Travis Ens <ens.travis@gmail.com>
+Evgenia Karunus <lakesare@gmail.com>
+Risiraj Dey <risirajdey@gmail.com>
+lastcodestanding <rohang71604@gmail.com>
+Andrey Lekar <andrey_lekar@adoriasoft.com>
+Abbas Mohammed <42001049+iam-abbas@users.noreply.github.com>
+Anutosh Bhat <andersonbhat491@gmail.com>
+Steve Kieffer <sk@skieffer.info>
+Paul Spiering <paul@spiering.org>
+Pieter Gijsbers <p.gijsbers@tue.nl>
+Wang Ran (汪然) <wangr@smail.nju.edu.cn>
+naelsondouglas <naelson17@gmail.com>
+Aman Thakur <thakuraman22july@gmail.com>
+S. Hanko <suzy.hanko@gmail.com>
+Dennis Sweeney <sweeney.427@osu.edu>
+Gurpartap Singh <dhaliwal.gurpartap@gmail.com>
+Hampus Malmberg <hampus.malmberg88@gmail.com>
+scimax <max.kellermeier@hotmail.de>
+Nikhil Date <nikhil.s.date@gmail.com>
+Kuldeep Borkar Jr <kuldeepborkarjr765@gmail.com>
+AkuBrain <76952313+Franck2111@users.noreply.github.com>
+Leo Battle <leowbattle@gmail.com>
+Advait Pote <apote2050@gmail.com>
+Anurag Bhat <bhat.1@iitj.ac.in>
+Jeremy Monat <jemonat@calalum.org>
+Diane Tchuindjo <dtchuindjo@gmail.com>
+Tom Fryers <61272761+TomFryers@users.noreply.github.com>
+Zouhair <zouhair.mahboubi@gmail.com>
+zzj <29055749+zjzh@users.noreply.github.com>
+shubhayu09 <guptashubhayu601@gmail.com>
+Siddhant Jain <siddhantashoknagar@gmail.com>
+Tirthankar Mazumder <63574588+wermos@users.noreply.github.com>
+Sumit Kumar <mr.sumitkrr@gmail.com>
+Shivam Sagar <technoshivam12@gmail.com>
+Gaurav Jain <gjain369@gmail.com>
+Andrii Oriekhov <andriyorehov@gmail.com>
+Luis Talavera <luisfertalavera15@gmail.com>
+Arie Bovenberg <a.c.bovenberg@gmail.com>
+Carson McManus <carson.mcmanus1@gmail.com>
+Jack Schmidt <1107865+jackschmidt@users.noreply.github.com>
+Riley Britten <nrb1324@hotmail.com>
+Georges Khaznadar <georgesk@debian.org>
+Donald Wilson <donwilson1029@gmail.com>
+Timo Stienstra <timostienstra00@gmail.com>
+dispasha <dispasha@users.noreply.github.com>
+Saksham Alok <sakshamalok13@gmail.com>
+Varenyam Bhardwaj <varenyambhardwaj123@gmail.com>
+oittaa <8972248+oittaa@users.noreply.github.com>
+Omkaar <79257339+Pysics@users.noreply.github.com>
+Islem BOUZENIA <fi_bouzenia@esi.dz>
+extraymond <extraymond@gmail.com>
+Alexander Behrens <alex.git@gmx.net>
+user202729 <25191436+user202729@users.noreply.github.com>
+Pieter Eendebak <pieter.eendebak@gmail.com>
+Zaz Brown <zazbrown@zazbrown.com>
+ritikBhandari <ritikbhandari68@gmail.com>
+viocha <66580331+viocha@users.noreply.github.com>
+Arthur Ryman <arthur.ryman@gmail.com>
+Xiang Wu <hsiangwu@fb.com>
+tttc3 <T.Coxon2@lboro.ac.uk>
+Seth Poulsen <poulsenseth@yahoo.com>
+cocolato <haiizhu@outlook.com>
+Anton Golovanov <agolovanov256@gmail.com>
+Gareth Ma <grhkm21@gmail.com>
+Clément M.T. Robert <cr52@protonmail.com>
+Glenn Horton-Smith <glenn.hortonsmith@gmail.com>
+Karan <grgkaran03@gmail.com>
+Stefan Behnle <84378403+behnle@users.noreply.github.com>
+Shreyash Mishra <72146041+Shreyash-cyber@users.noreply.github.com>
+Arthur Milchior <arthur@milchior.fr>
+NotWearingPants <26556598+NotWearingPants@users.noreply.github.com>
+Ishan Pandhare <ishan9096137017@gmail.com>
+Carlos García Montoro <TrilceAC@gmail.com>
+Parcly Taxel <reddeloostw@gmail.com>
+Saicharan <saicharanhahaha@gmail.com>
+Kunal Sheth <kunal@kunalsheth.info>
+Biswadeep Purkayastha <98874428+metabiswadeep@users.noreply.github.com>
+Jyn Spring 琴春 <me@vx.st>
+Phil LeMaitre <phil_lemaitre@live.ca>
+Chris Kerr <chris.kerr@mykolab.ch>
+José Senart <jose.senart@gmail.com>
+Uwe L. Korn <uwelk@xhochy.com>
+ForeverHaibara <69423537+ForeverHaibara@users.noreply.github.com>
+Yves Tumushimire <yvestumushimire@gmail.com>
+wookie184 <wookie1840@gmail.com>
+Costor <pcs2009@web.de>
+Klaus Rettinghaus <klaus.rettinghaus@enote.com>
+Sam Brockie <sambrockie@icloud.com>
+Abhishek Patidar <1e9abhi1e10@gmail.com>
+Eric Demer <demer@mailbox.org>
+Pontus von Brömssen <pontus.vonbromssen+github@gmail.com>
+Victor Immanuel <chrollolucilfer1402@gmail.com>
+Evandro Bernardes <evbernardes@gmail.com>
+Michele Ceccacci <michelececcacci1@gmail.com>
+Ayush Aryan <ayush.aryan71@gmail.com>
+Kishore Gopalakrishnan <kishore96@gmail.com>
+Jan-Philipp Hoffmann <sonntagsgesicht@icloud.com>
+Daiki Takahashi <haru.td@gmail.com>
+Sayan Mitra <ee18b156@smail.iitm.ac.in>
+Aman Kumar Shukla <theprofessionalaman@gmail.com>
+Zoufiné Lauer-Baré <raszoufine@gmail.com>
+Charles Harris <erdos4d@gmail.com>
+Tejaswini Sanapathi <sastejaswini2002@gmail.com>
+Devansh <be19b002@smail.iitm.ac.in>
+Aaron Gokaslan <aaronGokaslan@gmail.com>
+Daan Koning (he/him) <daanolivierkoning@gmail.com>
+Steven Burns <royalstream@hotmail.com>
+Jay Patankar <patankarjays@gmail.com>
+Vivek Soni <sonisheela1977@gmail.com>
+Le Cong Minh Hieu <hieu.lecongminh@gmail.com>
+Sam Ritchie <sam@mentat.org>
+Maciej Skórski <maciej.skorski@gmail.com>
+Tilo Reneau-Cardoso <tiloreneau@gmail.com>
+Laurence Warne <laurencewarne@gmail.com>
+Lukas Molleman <Lukas.Molleman@gmail.com>
+Konstantinos Riganas <kostasriganas24@gmail.com>
+Grace Su <grace.duansu@gmail.com>
+Pedro Rosa <pedro_sxbr@usp.br>
+Abhinav Cillanki <abhinavcillanki@kgpian.iitkgp.ac.in>
+Baiyuan Qiu <1061688677@qq.com>
+Liwei Cai <cai.lw123@gmail.com>
+Daniel Weindl <daniel.weindl@helmholtz-muenchen.de>
+Isidora Araya <iarayaday@gmail.com>
+Seb Tiburzio <sebtiburzio@gmail.com>
+Victory Omole <vtomole2@gmail.com>
+Abhishek Chaudhary <ac5003@columbia.edu>
+Alexander Zhura <nice.zhura@list.ru>
+Shuai Zhou <shuaivzhou@berkeley.edu>
+Martin Manns <mmanns@gmx.net>
+John Möller <john.moller@outlook.com>
+zzc <1378113190@qq.com>
+Pablo Galindo Salgado <pablogsal@gmail.com>
+Johannes Kasimir <johannes.kasimir@math.lu.se>
+Theodore Dias <theodore.dias@hotmail.co.uk>
+Kaustubh <90597818+kaustubh-765@users.noreply.github.com>
+Idan Pazi <idan.kp@gmail.com>
+Bobby Palmer <bobbyp@umich.edu>
+Saikat Das <saikatdchhe@gmail.com>
+Suman mondal <smondal.qwerty@gmail.com>
+Taylan Sahin <info@taylansahin.net>
+Fabio Luporini <fabio@devitocodes.com>
+Oriel Malihi <orielmalihi1@gmail.com>
+Geetika Vadali <geetika.vadali4@gmail.com>
+Matthias Rettl <matthias.rettl@stud.unileoben.ac.at>
+Mikhail Remnev <maremnev@gmail.com>
+philwillnyc <56197213+philwillnyc@users.noreply.github.com>
+Raphael Lehner <raphael.lehner@gmail.com>
+Harry Mountain <harrymountain1@icloud.com>
+Bhavik Sachdev <b.sachdev1904@gmail.com>
+袁野 (Yuan Ye) <yuanyelele@tutanota.com>
+fazledyn-or <ataf@openrefactory.com>
+mohammedouahman <simofun85@gmail.com>
+K. Kraus <laqueray@googlemail.com>
+Zac Hatfield-Dodds <zac.hatfield.dodds@gmail.com>
+platypus <platypus.computerchip@gmail.com>
+codecruisader <nnisarg55@gmail.com>
+James Whitehead <whiteheadj@gmail.com>
+atharvParlikar <atharvparlikar@gmail.com>
+Ivan Petukhov <satels@gmail.com>
+Augusto Borges <borges.augustoar@gmail.com>
+Han Wei Ang <ang.h.w@u.nus.edu>
+Congxu Yang <u7189828@anu.edu.au>
+Saicharan <62512681+saicharan2804@users.noreply.github.com>
+Arnab Nandi <arnabnandi2002@gmail.com>
+Harrison Oates <48871176+HarrisonOates@users.noreply.github.com>
+Corey Cerovsek <corey@cerovsek.com>
+Harsh Kasat <hkasat@waymore.io>
+omahs <73983677+omahs@users.noreply.github.com>
+Pascal Gitz <pascal.gitz@hotmail.ch>
+Ravindu-Hirimuthugoda <ravindu.18@cse.mrt.ac.lk>
+Sophia Pustova <tripplezzed@gmail.com>
+George Pittock <gpittock4@gmail.com>
+Warren Jacinto <warrenjacinto@gmail.com>
+Sachin Singh <sachinishu02@gmail.com>
+Zedmat <104870914+harshkasat@users.noreply.github.com>
+Soumendra Ganguly <soumendraganguly@gmail.com>
+Samith Karunathilake <55777141+samithkavishke@users.noreply.github.com>
+Viraj Vekaria <virajv5593@gmail.com>
+Shishir Kushwaha <kushwahashishir1112@gmail.com>
+Ankit Kumar Singh <ankitdiswar10@gmail.com>
+Abhishek Kumar <abhishek.nitdelhi@gmail.com>
+Mohak Malviya <mohakmalviya2000@gmail.com>
+Matthias Liesenfeld <116307294+maliesen@users.noreply.github.com>
+dodo <palumbododo@gmail.com>
+Mohamed Rezk <mohrizq895@gmail.com>
+Tommaso Vaccari <05-gesto-follemente@icloud.com>
+Alexis Schotte <alexis.schotte@gmail.com>
+Lauren Yim <31467609+cherryblossom000@users.noreply.github.com>
+Prey Patel <patel.prey@iitgn.ac.in>
+Riccardo Di Girolamo <riccardodigirolamo01@gmail.com>
+Abhishek kumar <kumar325571@gmail.com>
+Sam Lubelsky <sammy56lt@gmail.com>
+Henrique Soares <henrique.c.soares@tecnico.ulisboa.pt>
+Vladimir Sereda <voffch@gmail.com>
+Hwayeon Kang <hwayeonniii@gmail.com>
+Raj Sapale <raj4sapale4@gmail.com>
+Gerald Teschl <gerald.teschl@univie.ac.at>
+Richard Samuel <98638849+samuelard7@users.noreply.github.com>
+HeeJae Chang <hechang@microsoft.com>
+Nick Harder <nharder@umich.edu>
+Ethan DeGuire <ethandeguire@gmail.com>
+Lorenz Winkler <lorenz.winkler@tuwien.ac.at>
+Richard Rodenbusch <rrodenbusch@gmail.com>
+Zhenxu Zhu <xzdlj@outlook.com>
+Mark van Gelder <m.j.vangelder@student.tudelft.nl>
+Mark van Gelder <mvgmvgmvg@live.com>
+Ishan Pandhare <91841626+Ishanned@users.noreply.github.com>
+James A. Preiss <jamesalanpreiss@gmail.com>
+Emile Fourcini <emile.fourcin1@gmail.com>
+Alberto Jiménez Ruiz <Alberto.Jimenez@uclm.es>
+João Bravo <joaocgbravo@tecnico.ulisboa.pt>
+Dean Price <dean1357price1357@gmail.com>
+Edward Z. Yang <ezyang@mit.edu>
+James Titus <titusjames299@gmail.com>
+Zhuoyuan Li <zy.li@stu.pku.edu.cn>
+Hugo Kerstens <hugo@kerstens.me>
+Jan Jancar <johny@neuromancer.sk>
+Andrew Mosson <amosson@yahoo.com>
+Marek Madejski <marekmadejski@yandex.com>
+Gonzalo Tornaría <tornaria@cmat.edu.uy>
+Peter Stahlecker <peter.stahlecker@gmail.com>
+Jean-François B <2589111+jfbu@users.noreply.github.com>
+Zexuan Zhou (Bruce) <zzx498636727@gmail.com>
+George Frolov <gosha@fro.lv>
+Corbet Elkins <corbet286@gmail.com>
+Håkon Kvernmoen <haakon.kvernmoen@gmail.com>
+Muhammad Maaz <mmaaz6004@gmail.com>
+Shishir Kushwaha <138311586+shishir-11@users.noreply.github.com>
+Matt Wang <mattwang44@gmail.com>
+bharatAmeria <21001019007@jcboseust.ac.in>
+Amir Ebrahimi <github@aebrahimi.com>
+Steven Esquea <steven.esquea@irreverente.net>
+Rishabh Kamboj <111004091+VectorNd@users.noreply.github.com>
+Aasim Ali <aasim250205@gmail.com>
+Ivan A. Melnikov <iv@altlinux.org>
+Borek Saheli <boreksaheli@gmail.com>
+Guido Roncarolo <guido.roncarolo@gmail.com>
+Quek Zi Yao <ziyaoqzy2001@gmail.com>
+Roelof Rietbroek <r.rietbroek@utwente.nl>
+MostafaGalal1 <mostafag649.mg@gmail.com>
+Au Huishan <huishan_au@outlook.com>
+Kris Katterjohn <katterjohn@gmail.com>
+Shiyao Guo <mivikq@gmail.com>
+Rushabh Mehta <mehtarushabh2005@gmail.com>
+Temiloluwa Yusuf ytemiloluwa@gmail.com ytemiloluwa <ytemiloluwa@gmail.com>
+Davi Laerte <davilae011@gmail.com>
+Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com>
+Harshit Gupta <harshithigh2001@gmail.com>
+Praveen Perumal <ppraveen98841@gmail.com>
+Kevin McWhirter <klmcw@yahoo.com>
+Prayag V <v.prayag2005@gmail.com>
+Lucas Kletzander <lucas.kletzander@gmail.com>
+Pratyksh Gupta <pratykshgupta9999@gmail.com>
+Leonardo Mangani <leomangani4@gmail.com>
+Karan Anand <anandkarancompsci@gmail.com>
+Gagan Mishra <simonsimple305@gmail.com>
+Krishnav Bajoria <bajoriakrishnav@gmail.com>
+Matt Ord <matthew.ord1@gmail.com>
+Jatin Bhardwaj <bhardwajjatin093@gmail.com>
+Prashant Tandon <tandonprashant101@gmail.com>
+Paramjit Singh <paramjit1071@gmail.com>
+João Rodrigues <abcjoao@hotmail.com>
+Alejandro García Prada <114813960+AlexGarciaPrada@users.noreply.github.com>
+Matthew Treinish <mtreinish@kortar.org>
+Clayton Rabideau <claytonrabideau@gmail.com>
+Victoria Koval <bictoriakoval16@gmail.com>
+Voaides Negustor Robert <134785947+voaidesr@users.noreply.github.com>
+Ovsk Mendov <bbb23exposed@gmail.com>
+David Brooks <dave@bcs.co.nz>
+Nicholas Laustrup <124007393+nicklaustrup@users.noreply.github.com>
+Harikrishna Srinivasan <harikrishnasri3@gmail.com>
+Mathis Cros <mathis.cros@telecom-paris.fr>
+Arnav Mummineni <45217840+RCoder01@users.noreply.github.com>
+Thangaraju Sibiraj <85477603+t-sibiraj@users.noreply.github.com>
+KJaybhaye <krushnajaybhaye01@gmail.com>

venv/lib/python3.11/site-packages/sympy-1.14.0.dist-info/licenses/LICENSE

@@ -0,0 +1,153 @@
+Copyright (c) 2006-2023 SymPy Development Team
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  a. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+  b. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  c. Neither the name of SymPy nor the names of its contributors
+     may be used to endorse or promote products derived from this software
+     without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
+--------------------------------------------------------------------------------
+
+Patches that were taken from the Diofant project (https://github.com/diofant/diofant)
+are licensed as:
+
+Copyright (c) 2006-2018 SymPy Development Team,
+              2013-2023 Sergey B Kirpichev
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  a. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+  b. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  c. Neither the name of Diofant or SymPy nor the names of its contributors
+     may be used to endorse or promote products derived from this software
+     without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
+--------------------------------------------------------------------------------
+
+Submodules taken from the multipledispatch project (https://github.com/mrocklin/multipledispatch)
+are licensed as:
+
+Copyright (c) 2014 Matthew Rocklin
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  a. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+  b. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  c. Neither the name of multipledispatch nor the names of its contributors
+     may be used to endorse or promote products derived from this software
+     without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
+--------------------------------------------------------------------------------
+
+The files under the directory sympy/parsing/autolev/tests/pydy-example-repo
+are directly copied from PyDy project and are licensed as:
+
+Copyright (c) 2009-2023, PyDy Authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of this project nor the names of its contributors may be
+  used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL PYDY AUTHORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+--------------------------------------------------------------------------------
+
+The files under the directory sympy/parsing/latex 
+are directly copied from latex2sympy project and are licensed as:
+
+Copyright 2016, latex2sympy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

venv/lib/python3.11/site-packages/sympy-1.14.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+isympy
+sympy

venv/lib/python3.11/site-packages/sympy/physics/units/tests/test_dimensionsystem.py

@@ -0,0 +1,95 @@
+from sympy.core.symbol import symbols
+from sympy.matrices.dense import (Matrix, eye)
+from sympy.physics.units.definitions.dimension_definitions import (
+    action, current, length, mass, time,
+    velocity)
+from sympy.physics.units.dimensions import DimensionSystem
+
+
+def test_extend():
+    ms = DimensionSystem((length, time), (velocity,))
+
+    mks = ms.extend((mass,), (action,))
+
+    res = DimensionSystem((length, time, mass), (velocity, action))
+    assert mks.base_dims == res.base_dims
+    assert mks.derived_dims == res.derived_dims
+
+
+def test_list_dims():
+    dimsys = DimensionSystem((length, time, mass))
+
+    assert dimsys.list_can_dims == (length, mass, time)
+
+
+def test_dim_can_vector():
+    dimsys = DimensionSystem(
+        [length, mass, time],
+        [velocity, action],
+        {
+            velocity: {length: 1, time: -1}
+        }
+    )
+
+    assert dimsys.dim_can_vector(length) == Matrix([1, 0, 0])
+    assert dimsys.dim_can_vector(velocity) == Matrix([1, 0, -1])
+
+    dimsys = DimensionSystem(
+        (length, velocity, action),
+        (mass, time),
+        {
+            time: {length: 1, velocity: -1}
+        }
+    )
+
+    assert dimsys.dim_can_vector(length) == Matrix([0, 1, 0])
+    assert dimsys.dim_can_vector(velocity) == Matrix([0, 0, 1])
+    assert dimsys.dim_can_vector(time) == Matrix([0, 1, -1])
+
+    dimsys = DimensionSystem(
+        (length, mass, time),
+        (velocity, action),
+        {velocity: {length: 1, time: -1},
+         action: {mass: 1, length: 2, time: -1}})
+
+    assert dimsys.dim_vector(length) == Matrix([1, 0, 0])
+    assert dimsys.dim_vector(velocity) == Matrix([1, 0, -1])
+
+
+def test_inv_can_transf_matrix():
+    dimsys = DimensionSystem((length, mass, time))
+    assert dimsys.inv_can_transf_matrix == eye(3)
+
+
+def test_can_transf_matrix():
+    dimsys = DimensionSystem((length, mass, time))
+    assert dimsys.can_transf_matrix == eye(3)
+
+    dimsys = DimensionSystem((length, velocity, action))
+    assert dimsys.can_transf_matrix == eye(3)
+
+    dimsys = DimensionSystem((length, time), (velocity,), {velocity: {length: 1, time: -1}})
+    assert dimsys.can_transf_matrix == eye(2)
+
+
+def test_is_consistent():
+    assert DimensionSystem((length, time)).is_consistent is True
+
+
+def test_print_dim_base():
+    mksa = DimensionSystem(
+        (length, time, mass, current),
+        (action,),
+        {action: {mass: 1, length: 2, time: -1}})
+    L, M, T = symbols("L M T")
+    assert mksa.print_dim_base(action) == L**2*M/T
+
+
+def test_dim():
+    dimsys = DimensionSystem(
+        (length, mass, time),
+        (velocity, action),
+        {velocity: {length: 1, time: -1},
+         action: {mass: 1, length: 2, time: -1}}
+    )
+    assert dimsys.dim == 3

venv/lib/python3.11/site-packages/sympy/physics/units/tests/test_prefixes.py

@@ -0,0 +1,86 @@
+from sympy.core.mul import Mul
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.physics.units import Quantity, length, meter, W
+from sympy.physics.units.prefixes import PREFIXES, Prefix, prefix_unit, kilo, \
+    kibi
+from sympy.physics.units.systems import SI
+
+x = Symbol('x')
+
+
+def test_prefix_operations():
+    m = PREFIXES['m']
+    k = PREFIXES['k']
+    M = PREFIXES['M']
+
+    dodeca = Prefix('dodeca', 'dd', 1, base=12)
+
+    assert m * k is S.One
+    assert m * W == W / 1000
+    assert k * k == M
+    assert 1 / m == k
+    assert k / m == M
+
+    assert dodeca * dodeca == 144
+    assert 1 / dodeca == S.One / 12
+    assert k / dodeca == S(1000) / 12
+    assert dodeca / dodeca is S.One
+
+    m = Quantity("fake_meter")
+    SI.set_quantity_dimension(m, S.One)
+    SI.set_quantity_scale_factor(m, S.One)
+
+    assert dodeca * m == 12 * m
+    assert dodeca / m == 12 / m
+
+    expr1 = kilo * 3
+    assert isinstance(expr1, Mul)
+    assert expr1.args == (3, kilo)
+
+    expr2 = kilo * x
+    assert isinstance(expr2, Mul)
+    assert expr2.args == (x, kilo)
+
+    expr3 = kilo / 3
+    assert isinstance(expr3, Mul)
+    assert expr3.args == (Rational(1, 3), kilo)
+    assert expr3.args == (S.One/3, kilo)
+
+    expr4 = kilo / x
+    assert isinstance(expr4, Mul)
+    assert expr4.args == (1/x, kilo)
+
+
+def test_prefix_unit():
+    m = Quantity("fake_meter", abbrev="m")
+    m.set_global_relative_scale_factor(1, meter)
+
+    pref = {"m": PREFIXES["m"], "c": PREFIXES["c"], "d": PREFIXES["d"]}
+
+    q1 = Quantity("millifake_meter", abbrev="mm")
+    q2 = Quantity("centifake_meter", abbrev="cm")
+    q3 = Quantity("decifake_meter", abbrev="dm")
+
+    SI.set_quantity_dimension(q1, length)
+
+    SI.set_quantity_scale_factor(q1, PREFIXES["m"])
+    SI.set_quantity_scale_factor(q1, PREFIXES["c"])
+    SI.set_quantity_scale_factor(q1, PREFIXES["d"])
+
+    res = [q1, q2, q3]
+
+    prefs = prefix_unit(m, pref)
+    assert set(prefs) == set(res)
+    assert {v.abbrev for v in prefs} == set(symbols("mm,cm,dm"))
+
+
+def test_bases():
+    assert kilo.base == 10
+    assert kibi.base == 2
+
+
+def test_repr():
+    assert eval(repr(kilo)) == kilo
+    assert eval(repr(kibi)) == kibi

venv/lib/python3.11/site-packages/sympy/physics/units/tests/test_quantities.py

@@ -0,0 +1,575 @@
+import warnings
+
+from sympy.core.add import Add
+from sympy.core.function import (Function, diff)
+from sympy.core.numbers import (Number, Rational)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.integrals.integrals import integrate
+from sympy.physics.units import (amount_of_substance, area, convert_to, find_unit,
+                                 volume, kilometer, joule, molar_gas_constant,
+                                 vacuum_permittivity, elementary_charge, volt,
+                                 ohm)
+from sympy.physics.units.definitions import (amu, au, centimeter, coulomb,
+    day, foot, grams, hour, inch, kg, km, m, meter, millimeter,
+    minute, quart, s, second, speed_of_light, bit,
+    byte, kibibyte, mebibyte, gibibyte, tebibyte, pebibyte, exbibyte,
+    kilogram, gravitational_constant, electron_rest_mass)
+
+from sympy.physics.units.definitions.dimension_definitions import (
+    Dimension, charge, length, time, temperature, pressure,
+    energy, mass
+)
+from sympy.physics.units.prefixes import PREFIXES, kilo
+from sympy.physics.units.quantities import PhysicalConstant, Quantity
+from sympy.physics.units.systems import SI
+from sympy.testing.pytest import raises
+
+k = PREFIXES["k"]
+
+
+def test_str_repr():
+    assert str(kg) == "kilogram"
+
+
+def test_eq():
+    # simple test
+    assert 10*m == 10*m
+    assert 10*m != 10*s
+
+
+def test_convert_to():
+    q = Quantity("q1")
+    q.set_global_relative_scale_factor(S(5000), meter)
+
+    assert q.convert_to(m) == 5000*m
+
+    assert speed_of_light.convert_to(m / s) == 299792458 * m / s
+    assert day.convert_to(s) == 86400*s
+
+    # Wrong dimension to convert:
+    assert q.convert_to(s) == q
+    assert speed_of_light.convert_to(m) == speed_of_light
+
+    expr = joule*second
+    conv = convert_to(expr, joule)
+    assert conv == joule*second
+
+
+def test_Quantity_definition():
+    q = Quantity("s10", abbrev="sabbr")
+    q.set_global_relative_scale_factor(10, second)
+    u = Quantity("u", abbrev="dam")
+    u.set_global_relative_scale_factor(10, meter)
+    km = Quantity("km")
+    km.set_global_relative_scale_factor(kilo, meter)
+    v = Quantity("u")
+    v.set_global_relative_scale_factor(5*kilo, meter)
+
+    assert q.scale_factor == 10
+    assert q.dimension == time
+    assert q.abbrev == Symbol("sabbr")
+
+    assert u.dimension == length
+    assert u.scale_factor == 10
+    assert u.abbrev == Symbol("dam")
+
+    assert km.scale_factor == 1000
+    assert km.func(*km.args) == km
+    assert km.func(*km.args).args == km.args
+
+    assert v.dimension == length
+    assert v.scale_factor == 5000
+
+
+def test_abbrev():
+    u = Quantity("u")
+    u.set_global_relative_scale_factor(S.One, meter)
+
+    assert u.name == Symbol("u")
+    assert u.abbrev == Symbol("u")
+
+    u = Quantity("u", abbrev="om")
+    u.set_global_relative_scale_factor(S(2), meter)
+
+    assert u.name == Symbol("u")
+    assert u.abbrev == Symbol("om")
+    assert u.scale_factor == 2
+    assert isinstance(u.scale_factor, Number)
+
+    u = Quantity("u", abbrev="ikm")
+    u.set_global_relative_scale_factor(3*kilo, meter)
+
+    assert u.abbrev == Symbol("ikm")
+    assert u.scale_factor == 3000
+
+
+def test_print():
+    u = Quantity("unitname", abbrev="dam")
+    assert repr(u) == "unitname"
+    assert str(u) == "unitname"
+
+
+def test_Quantity_eq():
+    u = Quantity("u", abbrev="dam")
+    v = Quantity("v1")
+    assert u != v
+    v = Quantity("v2", abbrev="ds")
+    assert u != v
+    v = Quantity("v3", abbrev="dm")
+    assert u != v
+
+
+def test_add_sub():
+    u = Quantity("u")
+    v = Quantity("v")
+    w = Quantity("w")
+
+    u.set_global_relative_scale_factor(S(10), meter)
+    v.set_global_relative_scale_factor(S(5), meter)
+    w.set_global_relative_scale_factor(S(2), second)
+
+    assert isinstance(u + v, Add)
+    assert (u + v.convert_to(u)) == (1 + S.Half)*u
+    assert isinstance(u - v, Add)
+    assert (u - v.convert_to(u)) == S.Half*u
+
+
+def test_quantity_abs():
+    v_w1 = Quantity('v_w1')
+    v_w2 = Quantity('v_w2')
+    v_w3 = Quantity('v_w3')
+
+    v_w1.set_global_relative_scale_factor(1, meter/second)
+    v_w2.set_global_relative_scale_factor(1, meter/second)
+    v_w3.set_global_relative_scale_factor(1, meter/second)
+
+    expr = v_w3 - Abs(v_w1 - v_w2)
+
+    assert SI.get_dimensional_expr(v_w1) == (length/time).name
+
+    Dq = Dimension(SI.get_dimensional_expr(expr))
+
+    assert SI.get_dimension_system().get_dimensional_dependencies(Dq) == {
+        length: 1,
+        time: -1,
+    }
+    assert meter == sqrt(meter**2)
+
+
+def test_check_unit_consistency():
+    u = Quantity("u")
+    v = Quantity("v")
+    w = Quantity("w")
+
+    u.set_global_relative_scale_factor(S(10), meter)
+    v.set_global_relative_scale_factor(S(5), meter)
+    w.set_global_relative_scale_factor(S(2), second)
+
+    def check_unit_consistency(expr):
+        SI._collect_factor_and_dimension(expr)
+
+    raises(ValueError, lambda: check_unit_consistency(u + w))
+    raises(ValueError, lambda: check_unit_consistency(u - w))
+    raises(ValueError, lambda: check_unit_consistency(u + 1))
+    raises(ValueError, lambda: check_unit_consistency(u - 1))
+    raises(ValueError, lambda: check_unit_consistency(1 - exp(u / w)))
+
+
+def test_mul_div():
+    u = Quantity("u")
+    v = Quantity("v")
+    t = Quantity("t")
+    ut = Quantity("ut")
+    v2 = Quantity("v")
+
+    u.set_global_relative_scale_factor(S(10), meter)
+    v.set_global_relative_scale_factor(S(5), meter)
+    t.set_global_relative_scale_factor(S(2), second)
+    ut.set_global_relative_scale_factor(S(20), meter*second)
+    v2.set_global_relative_scale_factor(S(5), meter/second)
+
+    assert 1 / u == u**(-1)
+    assert u / 1 == u
+
+    v1 = u / t
+    v2 = v
+
+    # Pow only supports structural equality:
+    assert v1 != v2
+    assert v1 == v2.convert_to(v1)
+
+    # TODO: decide whether to allow such expression in the future
+    # (requires somehow manipulating the core).
+    # assert u / Quantity('l2', dimension=length, scale_factor=2) == 5
+
+    assert u * 1 == u
+
+    ut1 = u * t
+    ut2 = ut
+
+    # Mul only supports structural equality:
+    assert ut1 != ut2
+    assert ut1 == ut2.convert_to(ut1)
+
+    # Mul only supports structural equality:
+    lp1 = Quantity("lp1")
+    lp1.set_global_relative_scale_factor(S(2), 1/meter)
+    assert u * lp1 != 20
+
+    assert u**0 == 1
+    assert u**1 == u
+
+    # TODO: Pow only support structural equality:
+    u2 = Quantity("u2")
+    u3 = Quantity("u3")
+    u2.set_global_relative_scale_factor(S(100), meter**2)
+    u3.set_global_relative_scale_factor(Rational(1, 10), 1/meter)
+
+    assert u ** 2 != u2
+    assert u ** -1 != u3
+
+    assert u ** 2 == u2.convert_to(u)
+    assert u ** -1 == u3.convert_to(u)
+
+
+def test_units():
+    assert convert_to((5*m/s * day) / km, 1) == 432
+    assert convert_to(foot / meter, meter) == Rational(3048, 10000)
+    # amu is a pure mass so mass/mass gives a number, not an amount (mol)
+    # TODO: need better simplification routine:
+    assert str(convert_to(grams/amu, grams).n(2)) == '6.0e+23'
+
+    # Light from the sun needs about 8.3 minutes to reach earth
+    t = (1*au / speed_of_light) / minute
+    # TODO: need a better way to simplify expressions containing units:
+    t = convert_to(convert_to(t, meter / minute), meter)
+    assert t.simplify() == Rational(49865956897, 5995849160)
+
+    # TODO: fix this, it should give `m` without `Abs`
+    assert sqrt(m**2) == m
+    assert (sqrt(m))**2 == m
+
+    t = Symbol('t')
+    assert integrate(t*m/s, (t, 1*s, 5*s)) == 12*m*s
+    assert (t * m/s).integrate((t, 1*s, 5*s)) == 12*m*s
+
+
+def test_issue_quart():
+    assert convert_to(4 * quart / inch ** 3, meter) == 231
+    assert convert_to(4 * quart / inch ** 3, millimeter) == 231
+
+def test_electron_rest_mass():
+    assert convert_to(electron_rest_mass, kilogram) == 9.1093837015e-31*kilogram
+    assert convert_to(electron_rest_mass, grams) == 9.1093837015e-28*grams
+
+def test_issue_5565():
+    assert (m < s).is_Relational
+
+
+def test_find_unit():
+    assert find_unit('coulomb') == ['coulomb', 'coulombs', 'coulomb_constant']
+    assert find_unit(coulomb) == ['C', 'coulomb', 'coulombs', 'planck_charge', 'elementary_charge']
+    assert find_unit(charge) == ['C', 'coulomb', 'coulombs', 'planck_charge', 'elementary_charge']
+    assert find_unit(inch) == [
+        'm', 'au', 'cm', 'dm', 'ft', 'km', 'ly', 'mi', 'mm', 'nm', 'pm', 'um', 'yd',
+        'nmi', 'feet', 'foot', 'inch', 'mile', 'yard', 'meter', 'miles', 'yards',
+        'inches', 'meters', 'micron', 'microns', 'angstrom', 'angstroms', 'decimeter',
+        'kilometer', 'lightyear', 'nanometer', 'picometer', 'centimeter', 'decimeters',
+        'kilometers', 'lightyears', 'micrometer', 'millimeter', 'nanometers', 'picometers',
+        'centimeters', 'micrometers', 'millimeters', 'nautical_mile', 'planck_length',
+        'nautical_miles', 'astronomical_unit', 'astronomical_units']
+    assert find_unit(inch**-1) == ['D', 'dioptre', 'optical_power']
+    assert find_unit(length**-1) == ['D', 'dioptre', 'optical_power']
+    assert find_unit(inch ** 2) == ['ha', 'hectare', 'planck_area']
+    assert find_unit(inch ** 3) == [
+        'L', 'l', 'cL', 'cl', 'dL', 'dl', 'mL', 'ml', 'liter', 'quart', 'liters', 'quarts',
+        'deciliter', 'centiliter', 'deciliters', 'milliliter',
+        'centiliters', 'milliliters', 'planck_volume']
+    assert find_unit('voltage') == ['V', 'v', 'volt', 'volts', 'planck_voltage']
+    assert find_unit(grams) == ['g', 't', 'Da', 'kg', 'me', 'mg', 'ug', 'amu', 'mmu', 'amus',
+                                'gram', 'mmus', 'grams', 'pound', 'tonne', 'dalton', 'pounds',
+                                'kilogram', 'kilograms', 'microgram', 'milligram', 'metric_ton',
+                                'micrograms', 'milligrams', 'planck_mass', 'milli_mass_unit', 'atomic_mass_unit',
+                                'electron_rest_mass', 'atomic_mass_constant']
+
+
+def test_Quantity_derivative():
+    x = symbols("x")
+    assert diff(x*meter, x) == meter
+    assert diff(x**3*meter**2, x) == 3*x**2*meter**2
+    assert diff(meter, meter) == 1
+    assert diff(meter**2, meter) == 2*meter
+
+
+def test_quantity_postprocessing():
+    q1 = Quantity('q1')
+    q2 = Quantity('q2')
+
+    SI.set_quantity_dimension(q1, length*pressure**2*temperature/time)
+    SI.set_quantity_dimension(q2, energy*pressure*temperature/(length**2*time))
+
+    assert q1 + q2
+    q = q1 + q2
+    Dq = Dimension(SI.get_dimensional_expr(q))
+    assert SI.get_dimension_system().get_dimensional_dependencies(Dq) == {
+        length: -1,
+        mass: 2,
+        temperature: 1,
+        time: -5,
+    }
+
+
+def test_factor_and_dimension():
+    assert (3000, Dimension(1)) == SI._collect_factor_and_dimension(3000)
+    assert (1001, length) == SI._collect_factor_and_dimension(meter + km)
+    assert (2, length/time) == SI._collect_factor_and_dimension(
+        meter/second + 36*km/(10*hour))
+
+    x, y = symbols('x y')
+    assert (x + y/100, length) == SI._collect_factor_and_dimension(
+        x*m + y*centimeter)
+
+    cH = Quantity('cH')
+    SI.set_quantity_dimension(cH, amount_of_substance/volume)
+
+    pH = -log(cH)
+
+    assert (1, volume/amount_of_substance) == SI._collect_factor_and_dimension(
+        exp(pH))
+
+    v_w1 = Quantity('v_w1')
+    v_w2 = Quantity('v_w2')
+
+    v_w1.set_global_relative_scale_factor(Rational(3, 2), meter/second)
+    v_w2.set_global_relative_scale_factor(2, meter/second)
+
+    expr = Abs(v_w1/2 - v_w2)
+    assert (Rational(5, 4), length/time) == \
+        SI._collect_factor_and_dimension(expr)
+
+    expr = Rational(5, 2)*second/meter*v_w1 - 3000
+    assert (-(2996 + Rational(1, 4)), Dimension(1)) == \
+        SI._collect_factor_and_dimension(expr)
+
+    expr = v_w1**(v_w2/v_w1)
+    assert ((Rational(3, 2))**Rational(4, 3), (length/time)**Rational(4, 3)) == \
+        SI._collect_factor_and_dimension(expr)
+
+
+def test_dimensional_expr_of_derivative():
+    l = Quantity('l')
+    t = Quantity('t')
+    t1 = Quantity('t1')
+    l.set_global_relative_scale_factor(36, km)
+    t.set_global_relative_scale_factor(1, hour)
+    t1.set_global_relative_scale_factor(1, second)
+    x = Symbol('x')
+    y = Symbol('y')
+    f = Function('f')
+    dfdx = f(x, y).diff(x, y)
+    dl_dt = dfdx.subs({f(x, y): l, x: t, y: t1})
+    assert SI.get_dimensional_expr(dl_dt) ==\
+        SI.get_dimensional_expr(l / t / t1) ==\
+        Symbol("length")/Symbol("time")**2
+    assert SI._collect_factor_and_dimension(dl_dt) ==\
+        SI._collect_factor_and_dimension(l / t / t1) ==\
+        (10, length/time**2)
+
+
+def test_get_dimensional_expr_with_function():
+    v_w1 = Quantity('v_w1')
+    v_w2 = Quantity('v_w2')
+    v_w1.set_global_relative_scale_factor(1, meter/second)
+    v_w2.set_global_relative_scale_factor(1, meter/second)
+
+    assert SI.get_dimensional_expr(sin(v_w1)) == \
+        sin(SI.get_dimensional_expr(v_w1))
+    assert SI.get_dimensional_expr(sin(v_w1/v_w2)) == 1
+
+
+def test_binary_information():
+    assert convert_to(kibibyte, byte) == 1024*byte
+    assert convert_to(mebibyte, byte) == 1024**2*byte
+    assert convert_to(gibibyte, byte) == 1024**3*byte
+    assert convert_to(tebibyte, byte) == 1024**4*byte
+    assert convert_to(pebibyte, byte) == 1024**5*byte
+    assert convert_to(exbibyte, byte) == 1024**6*byte
+
+    assert kibibyte.convert_to(bit) == 8*1024*bit
+    assert byte.convert_to(bit) == 8*bit
+
+    a = 10*kibibyte*hour
+
+    assert convert_to(a, byte) == 10240*byte*hour
+    assert convert_to(a, minute) == 600*kibibyte*minute
+    assert convert_to(a, [byte, minute]) == 614400*byte*minute
+
+
+def test_conversion_with_2_nonstandard_dimensions():
+    good_grade = Quantity("good_grade")
+    kilo_good_grade = Quantity("kilo_good_grade")
+    centi_good_grade = Quantity("centi_good_grade")
+
+    kilo_good_grade.set_global_relative_scale_factor(1000, good_grade)
+    centi_good_grade.set_global_relative_scale_factor(S.One/10**5, kilo_good_grade)
+
+    charity_points = Quantity("charity_points")
+    milli_charity_points = Quantity("milli_charity_points")
+    missions = Quantity("missions")
+
+    milli_charity_points.set_global_relative_scale_factor(S.One/1000, charity_points)
+    missions.set_global_relative_scale_factor(251, charity_points)
+
+    assert convert_to(
+        kilo_good_grade*milli_charity_points*millimeter,
+        [centi_good_grade, missions, centimeter]
+    ) == S.One * 10**5 / (251*1000) / 10 * centi_good_grade*missions*centimeter
+
+
+def test_eval_subs():
+    energy, mass, force = symbols('energy mass force')
+    expr1 = energy/mass
+    units = {energy: kilogram*meter**2/second**2, mass: kilogram}
+    assert expr1.subs(units) == meter**2/second**2
+    expr2 = force/mass
+    units = {force:gravitational_constant*kilogram**2/meter**2, mass:kilogram}
+    assert expr2.subs(units) == gravitational_constant*kilogram/meter**2
+
+
+def test_issue_14932():
+    assert (log(inch) - log(2)).simplify() == log(inch/2)
+    assert (log(inch) - log(foot)).simplify() == -log(12)
+    p = symbols('p', positive=True)
+    assert (log(inch) - log(p)).simplify() == log(inch/p)
+
+
+def test_issue_14547():
+    # the root issue is that an argument with dimensions should
+    # not raise an error when the `arg - 1` calculation is
+    # performed in the assumptions system
+    from sympy.physics.units import foot, inch
+    from sympy.core.relational import Eq
+    assert log(foot).is_zero is None
+    assert log(foot).is_positive is None
+    assert log(foot).is_nonnegative is None
+    assert log(foot).is_negative is None
+    assert log(foot).is_algebraic is None
+    assert log(foot).is_rational is None
+    # doesn't raise error
+    assert Eq(log(foot), log(inch)) is not None  # might be False or unevaluated
+
+    x = Symbol('x')
+    e = foot + x
+    assert e.is_Add and set(e.args) == {foot, x}
+    e = foot + 1
+    assert e.is_Add and set(e.args) == {foot, 1}
+
+
+def test_issue_22164():
+    warnings.simplefilter("error")
+    dm = Quantity("dm")
+    SI.set_quantity_dimension(dm, length)
+    SI.set_quantity_scale_factor(dm, 1)
+
+    bad_exp = Quantity("bad_exp")
+    SI.set_quantity_dimension(bad_exp, length)
+    SI.set_quantity_scale_factor(bad_exp, 1)
+
+    expr = dm ** bad_exp
+
+    # deprecation warning is not expected here
+    SI._collect_factor_and_dimension(expr)
+
+
+def test_issue_22819():
+    from sympy.physics.units import tonne, gram, Da
+    from sympy.physics.units.systems.si import dimsys_SI
+    assert tonne.convert_to(gram) == 1000000*gram
+    assert dimsys_SI.get_dimensional_dependencies(area) == {length: 2}
+    assert Da.scale_factor == 1.66053906660000e-24
+
+
+def test_issue_20288():
+    from sympy.core.numbers import E
+    from sympy.physics.units import energy
+    u = Quantity('u')
+    v = Quantity('v')
+    SI.set_quantity_dimension(u, energy)
+    SI.set_quantity_dimension(v, energy)
+    u.set_global_relative_scale_factor(1, joule)
+    v.set_global_relative_scale_factor(1, joule)
+    expr = 1 + exp(u**2/v**2)
+    assert SI._collect_factor_and_dimension(expr) == (1 + E, Dimension(1))
+
+
+def test_issue_24062():
+    from sympy.core.numbers import E
+    from sympy.physics.units import impedance, capacitance, time, ohm, farad, second
+
+    R = Quantity('R')
+    C = Quantity('C')
+    T = Quantity('T')
+    SI.set_quantity_dimension(R, impedance)
+    SI.set_quantity_dimension(C, capacitance)
+    SI.set_quantity_dimension(T, time)
+    R.set_global_relative_scale_factor(1, ohm)
+    C.set_global_relative_scale_factor(1, farad)
+    T.set_global_relative_scale_factor(1, second)
+    expr = T / (R * C)
+    dim = SI._collect_factor_and_dimension(expr)[1]
+    assert SI.get_dimension_system().is_dimensionless(dim)
+
+    exp_expr = 1 + exp(expr)
+    assert SI._collect_factor_and_dimension(exp_expr) == (1 + E, Dimension(1))
+
+def test_issue_24211():
+    from sympy.physics.units import time, velocity, acceleration, second, meter
+    V1 = Quantity('V1')
+    SI.set_quantity_dimension(V1, velocity)
+    SI.set_quantity_scale_factor(V1, 1 * meter / second)
+    A1 = Quantity('A1')
+    SI.set_quantity_dimension(A1, acceleration)
+    SI.set_quantity_scale_factor(A1, 1 * meter / second**2)
+    T1 = Quantity('T1')
+    SI.set_quantity_dimension(T1, time)
+    SI.set_quantity_scale_factor(T1, 1 * second)
+
+    expr = A1*T1 + V1
+    # should not throw ValueError here
+    SI._collect_factor_and_dimension(expr)
+
+
+def test_prefixed_property():
+    assert not meter.is_prefixed
+    assert not joule.is_prefixed
+    assert not day.is_prefixed
+    assert not second.is_prefixed
+    assert not volt.is_prefixed
+    assert not ohm.is_prefixed
+    assert centimeter.is_prefixed
+    assert kilometer.is_prefixed
+    assert kilogram.is_prefixed
+    assert pebibyte.is_prefixed
+
+def test_physics_constant():
+    from sympy.physics.units import definitions
+
+    for name in dir(definitions):
+        quantity = getattr(definitions, name)
+        if not isinstance(quantity, Quantity):
+            continue
+        if name.endswith('_constant'):
+            assert isinstance(quantity, PhysicalConstant), f"{quantity} must be PhysicalConstant, but is {type(quantity)}"
+            assert quantity.is_physical_constant, f"{name} is not marked as physics constant when it should be"
+
+    for const in [gravitational_constant, molar_gas_constant, vacuum_permittivity, speed_of_light, elementary_charge]:
+        assert isinstance(const, PhysicalConstant), f"{const} must be PhysicalConstant, but is {type(const)}"
+        assert const.is_physical_constant, f"{const} is not marked as physics constant when it should be"
+
+    assert not meter.is_physical_constant
+    assert not joule.is_physical_constant

venv/lib/python3.11/site-packages/sympy/physics/units/tests/test_unit_system_cgs_gauss.py

@@ -0,0 +1,55 @@
+from sympy.concrete.tests.test_sums_products import NS
+
+from sympy.core.singleton import S
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.physics.units import convert_to, coulomb_constant, elementary_charge, gravitational_constant, planck
+from sympy.physics.units.definitions.unit_definitions import angstrom, statcoulomb, coulomb, second, gram, centimeter, erg, \
+    newton, joule, dyne, speed_of_light, meter, farad, henry, statvolt, volt, ohm
+from sympy.physics.units.systems import SI
+from sympy.physics.units.systems.cgs import cgs_gauss
+
+
+def test_conversion_to_from_si():
+    assert convert_to(statcoulomb, coulomb, cgs_gauss) == coulomb/2997924580
+    assert convert_to(coulomb, statcoulomb, cgs_gauss) == 2997924580*statcoulomb
+    assert convert_to(statcoulomb, sqrt(gram*centimeter**3)/second, cgs_gauss) == centimeter**(S(3)/2)*sqrt(gram)/second
+    assert convert_to(coulomb, sqrt(gram*centimeter**3)/second, cgs_gauss) == 2997924580*centimeter**(S(3)/2)*sqrt(gram)/second
+
+    # SI units have an additional base unit, no conversion in case of electromagnetism:
+    assert convert_to(coulomb, statcoulomb, SI) == coulomb
+    assert convert_to(statcoulomb, coulomb, SI) == statcoulomb
+
+    # SI without electromagnetism:
+    assert convert_to(erg, joule, SI) == joule/10**7
+    assert convert_to(erg, joule, cgs_gauss) == joule/10**7
+    assert convert_to(joule, erg, SI) == 10**7*erg
+    assert convert_to(joule, erg, cgs_gauss) == 10**7*erg
+
+
+    assert convert_to(dyne, newton, SI) == newton/10**5
+    assert convert_to(dyne, newton, cgs_gauss) == newton/10**5
+    assert convert_to(newton, dyne, SI) == 10**5*dyne
+    assert convert_to(newton, dyne, cgs_gauss) == 10**5*dyne
+
+
+def test_cgs_gauss_convert_constants():
+
+    assert convert_to(speed_of_light, centimeter/second, cgs_gauss) == 29979245800*centimeter/second
+
+    assert convert_to(coulomb_constant, 1, cgs_gauss) == 1
+    assert convert_to(coulomb_constant, newton*meter**2/coulomb**2, cgs_gauss) == 22468879468420441*meter**2*newton/(2500000*coulomb**2)
+    assert convert_to(coulomb_constant, newton*meter**2/coulomb**2, SI) == 22468879468420441*meter**2*newton/(2500000*coulomb**2)
+    assert convert_to(coulomb_constant, dyne*centimeter**2/statcoulomb**2, cgs_gauss) == centimeter**2*dyne/statcoulomb**2
+    assert convert_to(coulomb_constant, 1, SI) == coulomb_constant
+    assert NS(convert_to(coulomb_constant, newton*meter**2/coulomb**2, SI)) == '8987551787.36818*meter**2*newton/coulomb**2'
+
+    assert convert_to(elementary_charge, statcoulomb, cgs_gauss)
+    assert convert_to(angstrom, centimeter, cgs_gauss) == 1*centimeter/10**8
+    assert convert_to(gravitational_constant, dyne*centimeter**2/gram**2, cgs_gauss)
+    assert NS(convert_to(planck, erg*second, cgs_gauss)) == '6.62607015e-27*erg*second'
+
+    spc = 25000*second/(22468879468420441*centimeter)
+    assert convert_to(ohm, second/centimeter, cgs_gauss) == spc
+    assert convert_to(henry, second**2/centimeter, cgs_gauss) == spc*second
+    assert convert_to(volt, statvolt, cgs_gauss) == 10**6*statvolt/299792458
+    assert convert_to(farad, centimeter, cgs_gauss) == 299792458**2*centimeter/10**5

venv/lib/python3.11/site-packages/sympy/physics/units/tests/test_unitsystem.py

@@ -0,0 +1,86 @@
+from sympy.physics.units import DimensionSystem, joule, second, ampere
+
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.physics.units.definitions import c, kg, m, s
+from sympy.physics.units.definitions.dimension_definitions import length, time
+from sympy.physics.units.quantities import Quantity
+from sympy.physics.units.unitsystem import UnitSystem
+from sympy.physics.units.util import convert_to
+
+
+def test_definition():
+    # want to test if the system can have several units of the same dimension
+    dm = Quantity("dm")
+    base = (m, s)
+    # base_dim = (m.dimension, s.dimension)
+    ms = UnitSystem(base, (c, dm), "MS", "MS system")
+    ms.set_quantity_dimension(dm, length)
+    ms.set_quantity_scale_factor(dm, Rational(1, 10))
+
+    assert set(ms._base_units) == set(base)
+    assert set(ms._units) == {m, s, c, dm}
+    # assert ms._units == DimensionSystem._sort_dims(base + (velocity,))
+    assert ms.name == "MS"
+    assert ms.descr == "MS system"
+
+
+def test_str_repr():
+    assert str(UnitSystem((m, s), name="MS")) == "MS"
+    assert str(UnitSystem((m, s))) == "UnitSystem((meter, second))"
+
+    assert repr(UnitSystem((m, s))) == "<UnitSystem: (%s, %s)>" % (m, s)
+
+
+def test_convert_to():
+    A = Quantity("A")
+    A.set_global_relative_scale_factor(S.One, ampere)
+
+    Js = Quantity("Js")
+    Js.set_global_relative_scale_factor(S.One, joule*second)
+
+    mksa = UnitSystem((m, kg, s, A), (Js,))
+    assert convert_to(Js, mksa._base_units) == m**2*kg*s**-1/1000
+
+
+def test_extend():
+    ms = UnitSystem((m, s), (c,))
+    Js = Quantity("Js")
+    Js.set_global_relative_scale_factor(1, joule*second)
+    mks = ms.extend((kg,), (Js,))
+
+    res = UnitSystem((m, s, kg), (c, Js))
+    assert set(mks._base_units) == set(res._base_units)
+    assert set(mks._units) == set(res._units)
+
+
+def test_dim():
+    dimsys = UnitSystem((m, kg, s), (c,))
+    assert dimsys.dim == 3
+
+
+def test_is_consistent():
+    dimension_system = DimensionSystem([length, time])
+    us = UnitSystem([m, s], dimension_system=dimension_system)
+    assert us.is_consistent == True
+
+
+def test_get_units_non_prefixed():
+    from sympy.physics.units import volt, ohm
+    unit_system = UnitSystem.get_unit_system("SI")
+    units = unit_system.get_units_non_prefixed()
+    for prefix in ["giga", "tera", "peta", "exa", "zetta", "yotta", "kilo", "hecto", "deca", "deci", "centi", "milli", "micro", "nano", "pico", "femto", "atto", "zepto", "yocto"]:
+        for unit in units:
+            assert isinstance(unit, Quantity), f"{unit} must be a Quantity, not {type(unit)}"
+            assert not unit.is_prefixed, f"{unit} is marked as prefixed"
+            assert not unit.is_physical_constant, f"{unit} is marked as physics constant"
+            assert not unit.name.name.startswith(prefix), f"Unit {unit.name} has prefix {prefix}"
+    assert volt in units
+    assert ohm in units
+
+def test_derived_units_must_exist_in_unit_system():
+    for unit_system in UnitSystem._unit_systems.values():
+        for preferred_unit in unit_system.derived_units.values():
+            units = preferred_unit.atoms(Quantity)
+            for unit in units:
+                assert unit in unit_system._units, f"Unit {unit} is not in unit system {unit_system}"

venv/lib/python3.11/site-packages/sympy/physics/units/tests/test_util.py

@@ -0,0 +1,178 @@
+from sympy.core.containers import Tuple
+from sympy.core.numbers import pi
+from sympy.core.power import Pow
+from sympy.core.symbol import symbols
+from sympy.core.sympify import sympify
+from sympy.printing.str import sstr
+from sympy.physics.units import (
+    G, centimeter, coulomb, day, degree, gram, hbar, hour, inch, joule, kelvin,
+    kilogram, kilometer, length, meter, mile, minute, newton, planck,
+    planck_length, planck_mass, planck_temperature, planck_time, radians,
+    second, speed_of_light, steradian, time, km)
+from sympy.physics.units.util import convert_to, check_dimensions
+from sympy.testing.pytest import raises
+from sympy.functions.elementary.miscellaneous import sqrt
+
+
+def NS(e, n=15, **options):
+    return sstr(sympify(e).evalf(n, **options), full_prec=True)
+
+
+L = length
+T = time
+
+
+def test_dim_simplify_add():
+    # assert Add(L, L) == L
+    assert L + L == L
+
+
+def test_dim_simplify_mul():
+    # assert Mul(L, T) == L*T
+    assert L*T == L*T
+
+
+def test_dim_simplify_pow():
+    assert Pow(L, 2) == L**2
+
+
+def test_dim_simplify_rec():
+    # assert Mul(Add(L, L), T) == L*T
+    assert (L + L) * T == L*T
+
+
+def test_convert_to_quantities():
+    assert convert_to(3, meter) == 3
+
+    assert convert_to(mile, kilometer) == 25146*kilometer/15625
+    assert convert_to(meter/second, speed_of_light) == speed_of_light/299792458
+    assert convert_to(299792458*meter/second, speed_of_light) == speed_of_light
+    assert convert_to(2*299792458*meter/second, speed_of_light) == 2*speed_of_light
+    assert convert_to(speed_of_light, meter/second) == 299792458*meter/second
+    assert convert_to(2*speed_of_light, meter/second) == 599584916*meter/second
+    assert convert_to(day, second) == 86400*second
+    assert convert_to(2*hour, minute) == 120*minute
+    assert convert_to(mile, meter) == 201168*meter/125
+    assert convert_to(mile/hour, kilometer/hour) == 25146*kilometer/(15625*hour)
+    assert convert_to(3*newton, meter/second) == 3*newton
+    assert convert_to(3*newton, kilogram*meter/second**2) == 3*meter*kilogram/second**2
+    assert convert_to(kilometer + mile, meter) == 326168*meter/125
+    assert convert_to(2*kilometer + 3*mile, meter) == 853504*meter/125
+    assert convert_to(inch**2, meter**2) == 16129*meter**2/25000000
+    assert convert_to(3*inch**2, meter) == 48387*meter**2/25000000
+    assert convert_to(2*kilometer/hour + 3*mile/hour, meter/second) == 53344*meter/(28125*second)
+    assert convert_to(2*kilometer/hour + 3*mile/hour, centimeter/second) == 213376*centimeter/(1125*second)
+    assert convert_to(kilometer * (mile + kilometer), meter) == 2609344 * meter ** 2
+
+    assert convert_to(steradian, coulomb) == steradian
+    assert convert_to(radians, degree) == 180*degree/pi
+    assert convert_to(radians, [meter, degree]) == 180*degree/pi
+    assert convert_to(pi*radians, degree) == 180*degree
+    assert convert_to(pi, degree) == 180*degree
+
+    # https://github.com/sympy/sympy/issues/26263
+    assert convert_to(sqrt(meter**2 + meter**2.0), meter) == sqrt(meter**2 + meter**2.0)
+    assert convert_to((meter**2 + meter**2.0)**2, meter) == (meter**2 + meter**2.0)**2
+
+
+def test_convert_to_tuples_of_quantities():
+    from sympy.core.symbol import symbols
+
+    alpha, beta = symbols('alpha beta')
+
+    assert convert_to(speed_of_light, [meter, second]) == 299792458 * meter / second
+    assert convert_to(speed_of_light, (meter, second)) == 299792458 * meter / second
+    assert convert_to(speed_of_light, Tuple(meter, second)) == 299792458 * meter / second
+    assert convert_to(joule, [meter, kilogram, second]) == kilogram*meter**2/second**2
+    assert convert_to(joule, [centimeter, gram, second]) == 10000000*centimeter**2*gram/second**2
+    assert convert_to(299792458*meter/second, [speed_of_light]) == speed_of_light
+    assert convert_to(speed_of_light / 2, [meter, second, kilogram]) == meter/second*299792458 / 2
+    # This doesn't make physically sense, but let's keep it as a conversion test:
+    assert convert_to(2 * speed_of_light, [meter, second, kilogram]) == 2 * 299792458 * meter / second
+    assert convert_to(G, [G, speed_of_light, planck]) == 1.0*G
+
+    assert NS(convert_to(meter, [G, speed_of_light, hbar]), n=7) == '6.187142e+34*gravitational_constant**0.5000000*hbar**0.5000000/speed_of_light**1.500000'
+    assert NS(convert_to(planck_mass, kilogram), n=7) == '2.176434e-8*kilogram'
+    assert NS(convert_to(planck_length, meter), n=7) == '1.616255e-35*meter'
+    assert NS(convert_to(planck_time, second), n=6) == '5.39125e-44*second'
+    assert NS(convert_to(planck_temperature, kelvin), n=7) == '1.416784e+32*kelvin'
+    assert NS(convert_to(convert_to(meter, [G, speed_of_light, planck]), meter), n=10) == '1.000000000*meter'
+
+    # similar to https://github.com/sympy/sympy/issues/26263
+    assert convert_to(sqrt(meter**2 + second**2.0), [meter, second]) == sqrt(meter**2 + second**2.0)
+    assert convert_to((meter**2 + second**2.0)**2, [meter, second]) == (meter**2 + second**2.0)**2
+
+    # similar to https://github.com/sympy/sympy/issues/21463
+    assert convert_to(1/(beta*meter + meter), 1/meter) == 1/(beta*meter + meter)
+    assert convert_to(1/(beta*meter + alpha*meter), 1/kilometer) == (1/(kilometer*beta/1000 + alpha*kilometer/1000))
+
+def test_eval_simplify():
+    from sympy.physics.units import cm, mm, km, m, K, kilo
+    from sympy.core.symbol import symbols
+
+    x, y = symbols('x y')
+
+    assert (cm/mm).simplify() == 10
+    assert (km/m).simplify() == 1000
+    assert (km/cm).simplify() == 100000
+    assert (10*x*K*km**2/m/cm).simplify() == 1000000000*x*kelvin
+    assert (cm/km/m).simplify() == 1/(10000000*centimeter)
+
+    assert (3*kilo*meter).simplify() == 3000*meter
+    assert (4*kilo*meter/(2*kilometer)).simplify() == 2
+    assert (4*kilometer**2/(kilo*meter)**2).simplify() == 4
+
+
+def test_quantity_simplify():
+    from sympy.physics.units.util import quantity_simplify
+    from sympy.physics.units import kilo, foot
+    from sympy.core.symbol import symbols
+
+    x, y = symbols('x y')
+
+    assert quantity_simplify(x*(8*kilo*newton*meter + y)) == x*(8000*meter*newton + y)
+    assert quantity_simplify(foot*inch*(foot + inch)) == foot**2*(foot + foot/12)/12
+    assert quantity_simplify(foot*inch*(foot*foot + inch*(foot + inch))) == foot**2*(foot**2 + foot/12*(foot + foot/12))/12
+    assert quantity_simplify(2**(foot/inch*kilo/1000)*inch) == 4096*foot/12
+    assert quantity_simplify(foot**2*inch + inch**2*foot) == 13*foot**3/144
+
+def test_quantity_simplify_across_dimensions():
+    from sympy.physics.units.util import quantity_simplify
+    from sympy.physics.units import ampere, ohm, volt, joule, pascal, farad, second, watt, siemens, henry, tesla, weber, hour, newton
+
+    assert quantity_simplify(ampere*ohm, across_dimensions=True, unit_system="SI") == volt
+    assert quantity_simplify(6*ampere*ohm, across_dimensions=True, unit_system="SI") == 6*volt
+    assert quantity_simplify(volt/ampere, across_dimensions=True, unit_system="SI") == ohm
+    assert quantity_simplify(volt/ohm, across_dimensions=True, unit_system="SI") == ampere
+    assert quantity_simplify(joule/meter**3, across_dimensions=True, unit_system="SI") == pascal
+    assert quantity_simplify(farad*ohm, across_dimensions=True, unit_system="SI") == second
+    assert quantity_simplify(joule/second, across_dimensions=True, unit_system="SI") == watt
+    assert quantity_simplify(meter**3/second, across_dimensions=True, unit_system="SI") == meter**3/second
+    assert quantity_simplify(joule/second, across_dimensions=True, unit_system="SI") == watt
+
+    assert quantity_simplify(joule/coulomb, across_dimensions=True, unit_system="SI") == volt
+    assert quantity_simplify(volt/ampere, across_dimensions=True, unit_system="SI") == ohm
+    assert quantity_simplify(ampere/volt, across_dimensions=True, unit_system="SI") == siemens
+    assert quantity_simplify(coulomb/volt, across_dimensions=True, unit_system="SI") == farad
+    assert quantity_simplify(volt*second/ampere, across_dimensions=True, unit_system="SI") == henry
+    assert quantity_simplify(volt*second/meter**2, across_dimensions=True, unit_system="SI") == tesla
+    assert quantity_simplify(joule/ampere, across_dimensions=True, unit_system="SI") == weber
+
+    assert quantity_simplify(5*kilometer/hour, across_dimensions=True, unit_system="SI") == 25*meter/(18*second)
+    assert quantity_simplify(5*kilogram*meter/second**2, across_dimensions=True, unit_system="SI") == 5*newton
+
+def test_check_dimensions():
+    x = symbols('x')
+    assert check_dimensions(inch + x) == inch + x
+    assert check_dimensions(length + x) == length + x
+    # after subs we get 2*length; check will clear the constant
+    assert check_dimensions((length + x).subs(x, length)) == length
+    assert check_dimensions(newton*meter + joule) == joule + meter*newton
+    raises(ValueError, lambda: check_dimensions(inch + 1))
+    raises(ValueError, lambda: check_dimensions(length + 1))
+    raises(ValueError, lambda: check_dimensions(length + time))
+    raises(ValueError, lambda: check_dimensions(meter + second))
+    raises(ValueError, lambda: check_dimensions(2 * meter + second))
+    raises(ValueError, lambda: check_dimensions(2 * meter + 3 * second))
+    raises(ValueError, lambda: check_dimensions(1 / second + 1 / meter))
+    raises(ValueError, lambda: check_dimensions(2 * meter*(mile + centimeter) + km))

venv/lib/python3.11/site-packages/sympy/physics/units/unitsystem.py

@@ -0,0 +1,204 @@
+"""
+Unit system for physical quantities; include definition of constants.
+"""
+from __future__ import annotations
+
+from sympy.core.add import Add
+from sympy.core.function import (Derivative, Function)
+from sympy.core.mul import Mul
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.physics.units.dimensions import _QuantityMapper
+from sympy.physics.units.quantities import Quantity
+
+from .dimensions import Dimension
+
+
+class UnitSystem(_QuantityMapper):
+    """
+    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.
+
+    It is much better if all base units have a symbol.
+    """
+
+    _unit_systems: dict[str, UnitSystem] = {}
+
+    def __init__(self, base_units, units=(), name="", descr="", dimension_system=None, derived_units: dict[Dimension, Quantity]={}):
+
+        UnitSystem._unit_systems[name] = self
+
+        self.name = name
+        self.descr = descr
+
+        self._base_units = base_units
+        self._dimension_system = dimension_system
+        self._units = tuple(set(base_units) | set(units))
+        self._base_units = tuple(base_units)
+        self._derived_units = derived_units
+
+        super().__init__()
+
+    def __str__(self):
+        """
+        Return the name of the system.
+
+        If it does not exist, then it makes a list of symbols (or names) of
+        the base dimensions.
+        """
+
+        if self.name != "":
+            return self.name
+        else:
+            return "UnitSystem((%s))" % ", ".join(
+                str(d) for d in self._base_units)
+
+    def __repr__(self):
+        return '<UnitSystem: %s>' % repr(self._base_units)
+
+    def extend(self, base, units=(), name="", description="", dimension_system=None, derived_units: dict[Dimension, Quantity]={}):
+        """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.
+        If not provided, name and description are overridden by empty strings.
+        """
+
+        base = self._base_units + tuple(base)
+        units = self._units + tuple(units)
+
+        return UnitSystem(base, units, name, description, dimension_system, {**self._derived_units, **derived_units})
+
+    def get_dimension_system(self):
+        return self._dimension_system
+
+    def get_quantity_dimension(self, unit):
+        qdm = self.get_dimension_system()._quantity_dimension_map
+        if unit in qdm:
+            return qdm[unit]
+        return super().get_quantity_dimension(unit)
+
+    def get_quantity_scale_factor(self, unit):
+        qsfm = self.get_dimension_system()._quantity_scale_factors
+        if unit in qsfm:
+            return qsfm[unit]
+        return super().get_quantity_scale_factor(unit)
+
+    @staticmethod
+    def get_unit_system(unit_system):
+        if isinstance(unit_system, UnitSystem):
+            return unit_system
+
+        if unit_system not in UnitSystem._unit_systems:
+            raise ValueError(
+                "Unit system is not supported. Currently"
+                "supported unit systems are {}".format(
+                    ", ".join(sorted(UnitSystem._unit_systems))
+                )
+            )
+
+        return UnitSystem._unit_systems[unit_system]
+
+    @staticmethod
+    def get_default_unit_system():
+        return UnitSystem._unit_systems["SI"]
+
+    @property
+    def dim(self):
+        """
+        Give the dimension of the system.
+
+        That is return the number of units forming the basis.
+        """
+        return len(self._base_units)
+
+    @property
+    def is_consistent(self):
+        """
+        Check if the underlying dimension system is consistent.
+        """
+        # test is performed in DimensionSystem
+        return self.get_dimension_system().is_consistent
+
+    @property
+    def derived_units(self) -> dict[Dimension, Quantity]:
+        return self._derived_units
+
+    def get_dimensional_expr(self, expr):
+        from sympy.physics.units import Quantity
+        if isinstance(expr, Mul):
+            return Mul(*[self.get_dimensional_expr(i) for i in expr.args])
+        elif isinstance(expr, Pow):
+            return self.get_dimensional_expr(expr.base) ** expr.exp
+        elif isinstance(expr, Add):
+            return self.get_dimensional_expr(expr.args[0])
+        elif isinstance(expr, Derivative):
+            dim = self.get_dimensional_expr(expr.expr)
+            for independent, count in expr.variable_count:
+                dim /= self.get_dimensional_expr(independent)**count
+            return dim
+        elif isinstance(expr, Function):
+            args = [self.get_dimensional_expr(arg) for arg in expr.args]
+            if all(i == 1 for i in args):
+                return S.One
+            return expr.func(*args)
+        elif isinstance(expr, Quantity):
+            return self.get_quantity_dimension(expr).name
+        return S.One
+
+    def _collect_factor_and_dimension(self, expr):
+        """
+        Return tuple with scale factor expression and dimension expression.
+        """
+        from sympy.physics.units import Quantity
+        if isinstance(expr, Quantity):
+            return expr.scale_factor, expr.dimension
+        elif isinstance(expr, Mul):
+            factor = 1
+            dimension = Dimension(1)
+            for arg in expr.args:
+                arg_factor, arg_dim = self._collect_factor_and_dimension(arg)
+                factor *= arg_factor
+                dimension *= arg_dim
+            return factor, dimension
+        elif isinstance(expr, Pow):
+            factor, dim = self._collect_factor_and_dimension(expr.base)
+            exp_factor, exp_dim = self._collect_factor_and_dimension(expr.exp)
+            if self.get_dimension_system().is_dimensionless(exp_dim):
+                exp_dim = 1
+            return factor ** exp_factor, dim ** (exp_factor * exp_dim)
+        elif isinstance(expr, Add):
+            factor, dim = self._collect_factor_and_dimension(expr.args[0])
+            for addend in expr.args[1:]:
+                addend_factor, addend_dim = \
+                    self._collect_factor_and_dimension(addend)
+                if not self.get_dimension_system().equivalent_dims(dim, addend_dim):
+                    raise ValueError(
+                        'Dimension of "{}" is {}, '
+                        'but it should be {}'.format(
+                            addend, addend_dim, dim))
+                factor += addend_factor
+            return factor, dim
+        elif isinstance(expr, Derivative):
+            factor, dim = self._collect_factor_and_dimension(expr.args[0])
+            for independent, count in expr.variable_count:
+                ifactor, idim = self._collect_factor_and_dimension(independent)
+                factor /= ifactor**count
+                dim /= idim**count
+            return factor, dim
+        elif isinstance(expr, Function):
+            fds = [self._collect_factor_and_dimension(arg) for arg in expr.args]
+            dims = [Dimension(1) if self.get_dimension_system().is_dimensionless(d[1]) else d[1] for d in fds]
+            return (expr.func(*(f[0] for f in fds)), *dims)
+        elif isinstance(expr, Dimension):
+            return S.One, expr
+        else:
+            return expr, Dimension(1)
+
+    def get_units_non_prefixed(self) -> set[Quantity]:
+        """
+        Return the units of the system that do not have a prefix.
+        """
+        return set(filter(lambda u: not u.is_prefixed and not u.is_physical_constant, self._units))

venv/lib/python3.11/site-packages/sympy/physics/units/util.py

@@ -0,0 +1,265 @@
+"""
+Several methods to simplify expressions involving unit objects.
+"""
+from functools import reduce
+from collections.abc import Iterable
+from typing import Optional
+
+from sympy import default_sort_key
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.mul import Mul
+from sympy.core.power import Pow
+from sympy.core.sorting import ordered
+from sympy.core.sympify import sympify
+from sympy.core.function import Function
+from sympy.matrices.exceptions import NonInvertibleMatrixError
+from sympy.physics.units.dimensions import Dimension, DimensionSystem
+from sympy.physics.units.prefixes import Prefix
+from sympy.physics.units.quantities import Quantity
+from sympy.physics.units.unitsystem import UnitSystem
+from sympy.utilities.iterables import sift
+
+
+def _get_conversion_matrix_for_expr(expr, target_units, unit_system):
+    from sympy.matrices.dense import Matrix
+
+    dimension_system = unit_system.get_dimension_system()
+
+    expr_dim = Dimension(unit_system.get_dimensional_expr(expr))
+    dim_dependencies = dimension_system.get_dimensional_dependencies(expr_dim, mark_dimensionless=True)
+    target_dims = [Dimension(unit_system.get_dimensional_expr(x)) for x in target_units]
+    canon_dim_units = [i for x in target_dims for i in dimension_system.get_dimensional_dependencies(x, mark_dimensionless=True)]
+    canon_expr_units = set(dim_dependencies)
+
+    if not canon_expr_units.issubset(set(canon_dim_units)):
+        return None
+
+    seen = set()
+    canon_dim_units = [i for i in canon_dim_units if not (i in seen or seen.add(i))]
+
+    camat = Matrix([[dimension_system.get_dimensional_dependencies(i, mark_dimensionless=True).get(j, 0) for i in target_dims] for j in canon_dim_units])
+    exprmat = Matrix([dim_dependencies.get(k, 0) for k in canon_dim_units])
+
+    try:
+        res_exponents = camat.solve(exprmat)
+    except NonInvertibleMatrixError:
+        return None
+
+    return res_exponents
+
+
+def convert_to(expr, target_units, unit_system="SI"):
+    """
+    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
+    units/quantities.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.units import speed_of_light, meter, gram, second, day
+    >>> from sympy.physics.units import mile, newton, kilogram, atomic_mass_constant
+    >>> from sympy.physics.units import kilometer, centimeter
+    >>> from sympy.physics.units import gravitational_constant, hbar
+    >>> from sympy.physics.units import convert_to
+    >>> convert_to(mile, kilometer)
+    25146*kilometer/15625
+    >>> convert_to(mile, kilometer).n()
+    1.609344*kilometer
+    >>> convert_to(speed_of_light, meter/second)
+    299792458*meter/second
+    >>> convert_to(day, second)
+    86400*second
+    >>> 3*newton
+    3*newton
+    >>> convert_to(3*newton, kilogram*meter/second**2)
+    3*kilogram*meter/second**2
+    >>> convert_to(atomic_mass_constant, gram)
+    1.660539060e-24*gram
+
+    Conversion to multiple units:
+
+    >>> convert_to(speed_of_light, [meter, second])
+    299792458*meter/second
+    >>> convert_to(3*newton, [centimeter, gram, second])
+    300000*centimeter*gram/second**2
+
+    Conversion to Planck units:
+
+    >>> convert_to(atomic_mass_constant, [gravitational_constant, speed_of_light, hbar]).n()
+    7.62963087839509e-20*hbar**0.5*speed_of_light**0.5/gravitational_constant**0.5
+
+    """
+    from sympy.physics.units import UnitSystem
+    unit_system = UnitSystem.get_unit_system(unit_system)
+
+    if not isinstance(target_units, (Iterable, Tuple)):
+        target_units = [target_units]
+
+    def handle_Adds(expr):
+        return Add.fromiter(convert_to(i, target_units, unit_system)
+            for i in expr.args)
+
+    if isinstance(expr, Add):
+        return handle_Adds(expr)
+    elif isinstance(expr, Pow) and isinstance(expr.base, Add):
+        return handle_Adds(expr.base) ** expr.exp
+
+    expr = sympify(expr)
+    target_units = sympify(target_units)
+
+    if isinstance(expr, Function):
+        expr = expr.together()
+
+    if not isinstance(expr, Quantity) and expr.has(Quantity):
+        expr = expr.replace(lambda x: isinstance(x, Quantity),
+            lambda x: x.convert_to(target_units, unit_system))
+
+    def get_total_scale_factor(expr):
+        if isinstance(expr, Mul):
+            return reduce(lambda x, y: x * y,
+                [get_total_scale_factor(i) for i in expr.args])
+        elif isinstance(expr, Pow):
+            return get_total_scale_factor(expr.base) ** expr.exp
+        elif isinstance(expr, Quantity):
+            return unit_system.get_quantity_scale_factor(expr)
+        return expr
+
+    depmat = _get_conversion_matrix_for_expr(expr, target_units, unit_system)
+    if depmat is None:
+        return expr
+
+    expr_scale_factor = get_total_scale_factor(expr)
+    return expr_scale_factor * Mul.fromiter(
+        (1/get_total_scale_factor(u)*u)**p for u, p in
+        zip(target_units, depmat))
+
+
+def quantity_simplify(expr, across_dimensions: bool=False, unit_system=None):
+    """Return an equivalent expression in which prefixes are replaced
+    with numerical values and all units of a given dimension are the
+    unified in a canonical manner by default. `across_dimensions` allows
+    for units of different dimensions to be simplified together.
+
+    `unit_system` must be specified if `across_dimensions` is True.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.units.util import quantity_simplify
+    >>> from sympy.physics.units.prefixes import kilo
+    >>> from sympy.physics.units import foot, inch, joule, coulomb
+    >>> quantity_simplify(kilo*foot*inch)
+    250*foot**2/3
+    >>> quantity_simplify(foot - 6*inch)
+    foot/2
+    >>> quantity_simplify(5*joule/coulomb, across_dimensions=True, unit_system="SI")
+    5*volt
+    """
+
+    if expr.is_Atom or not expr.has(Prefix, Quantity):
+        return expr
+
+    # replace all prefixes with numerical values
+    p = expr.atoms(Prefix)
+    expr = expr.xreplace({p: p.scale_factor for p in p})
+
+    # replace all quantities of given dimension with a canonical
+    # quantity, chosen from those in the expression
+    d = sift(expr.atoms(Quantity), lambda i: i.dimension)
+    for k in d:
+        if len(d[k]) == 1:
+            continue
+        v = list(ordered(d[k]))
+        ref = v[0]/v[0].scale_factor
+        expr = expr.xreplace({vi: ref*vi.scale_factor for vi in v[1:]})
+
+    if across_dimensions:
+        # combine quantities of different dimensions into a single
+        # quantity that is equivalent to the original expression
+
+        if unit_system is None:
+            raise ValueError("unit_system must be specified if across_dimensions is True")
+
+        unit_system = UnitSystem.get_unit_system(unit_system)
+        dimension_system: DimensionSystem = unit_system.get_dimension_system()
+        dim_expr = unit_system.get_dimensional_expr(expr)
+        dim_deps = dimension_system.get_dimensional_dependencies(dim_expr, mark_dimensionless=True)
+
+        target_dimension: Optional[Dimension] = None
+        for ds_dim, ds_dim_deps in dimension_system.dimensional_dependencies.items():
+            if ds_dim_deps == dim_deps:
+                target_dimension = ds_dim
+                break
+
+        if target_dimension is None:
+            # if we can't find a target dimension, we can't do anything. unsure how to handle this case.
+            return expr
+
+        target_unit = unit_system.derived_units.get(target_dimension)
+        if target_unit:
+            expr = convert_to(expr, target_unit, unit_system)
+
+    return expr
+
+
+def check_dimensions(expr, unit_system="SI"):
+    """Return expr if units in addends have the same
+    base dimensions, else raise a ValueError."""
+    # the case of adding a number to a dimensional quantity
+    # is ignored for the sake of SymPy core routines, so this
+    # function will raise an error now if such an addend is
+    # found.
+    # Also, when doing substitutions, multiplicative constants
+    # might be introduced, so remove those now
+
+    from sympy.physics.units import UnitSystem
+    unit_system = UnitSystem.get_unit_system(unit_system)
+
+    def addDict(dict1, dict2):
+        """Merge dictionaries by adding values of common keys and
+        removing keys with value of 0."""
+        dict3 = {**dict1, **dict2}
+        for key, value in dict3.items():
+            if key in dict1 and key in dict2:
+                dict3[key] = value + dict1[key]
+        return {key:val for key, val in dict3.items() if val != 0}
+
+    adds = expr.atoms(Add)
+    DIM_OF = unit_system.get_dimension_system().get_dimensional_dependencies
+    for a in adds:
+        deset = set()
+        for ai in a.args:
+            if ai.is_number:
+                deset.add(())
+                continue
+            dims = []
+            skip = False
+            dimdict = {}
+            for i in Mul.make_args(ai):
+                if i.has(Quantity):
+                    i = Dimension(unit_system.get_dimensional_expr(i))
+                if i.has(Dimension):
+                    dimdict = addDict(dimdict, DIM_OF(i))
+                elif i.free_symbols:
+                    skip = True
+                    break
+            dims.extend(dimdict.items())
+            if not skip:
+                deset.add(tuple(sorted(dims, key=default_sort_key)))
+                if len(deset) > 1:
+                    raise ValueError(
+                        "addends have incompatible dimensions: {}".format(deset))
+
+    # clear multiplicative constants on Dimensions which may be
+    # left after substitution
+    reps = {}
+    for m in expr.atoms(Mul):
+        if any(isinstance(i, Dimension) for i in m.args):
+            reps[m] = m.func(*[
+                i for i in m.args if not i.is_number])
+
+    return expr.xreplace(reps)

venv/lib/python3.11/site-packages/sympy/physics/vector/__init__.py

@@ -0,0 +1,36 @@
+__all__ = [
+    'CoordinateSym', 'ReferenceFrame',
+
+    'Dyadic',
+
+    'Vector',
+
+    'Point',
+
+    'cross', 'dot', 'express', 'time_derivative', 'outer',
+    'kinematic_equations', 'get_motion_params', 'partial_velocity',
+    'dynamicsymbols',
+
+    'vprint', 'vsstrrepr', 'vsprint', 'vpprint', 'vlatex', 'init_vprinting',
+
+    'curl', 'divergence', 'gradient', 'is_conservative', 'is_solenoidal',
+    'scalar_potential', 'scalar_potential_difference',
+
+]
+from .frame import CoordinateSym, ReferenceFrame
+
+from .dyadic import Dyadic
+
+from .vector import Vector
+
+from .point import Point
+
+from .functions import (cross, dot, express, time_derivative, outer,
+        kinematic_equations, get_motion_params, partial_velocity,
+        dynamicsymbols)
+
+from .printing import (vprint, vsstrrepr, vsprint, vpprint, vlatex,
+        init_vprinting)
+
+from .fieldfunctions import (curl, divergence, gradient, is_conservative,
+        is_solenoidal, scalar_potential, scalar_potential_difference)

venv/lib/python3.11/site-packages/sympy/physics/vector/dyadic.py

@@ -0,0 +1,545 @@
+from sympy import sympify, Add, ImmutableMatrix as Matrix
+from sympy.core.evalf import EvalfMixin
+from sympy.printing.defaults import Printable
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+__all__ = ['Dyadic']
+
+
+class Dyadic(Printable, EvalfMixin):
+    """A Dyadic object.
+
+    See:
+    https://en.wikipedia.org/wiki/Dyadic_tensor
+    Kane, T., Levinson, D. Dynamics Theory and Applications. 1985 McGraw-Hill
+
+    A more powerful way to represent a rigid body's inertia. While it is more
+    complex, by choosing Dyadic components to be in body fixed basis vectors,
+    the resulting matrix is equivalent to the inertia tensor.
+
+    """
+
+    is_number = False
+
+    def __init__(self, inlist):
+        """
+        Just like Vector's init, you should not call this unless creating a
+        zero dyadic.
+
+        zd = Dyadic(0)
+
+        Stores a Dyadic as a list of lists; the inner list has the measure
+        number and the two unit vectors; the outerlist holds each unique
+        unit vector pair.
+
+        """
+
+        self.args = []
+        if inlist == 0:
+            inlist = []
+        while len(inlist) != 0:
+            added = 0
+            for i, v in enumerate(self.args):
+                if ((str(inlist[0][1]) == str(self.args[i][1])) and
+                        (str(inlist[0][2]) == str(self.args[i][2]))):
+                    self.args[i] = (self.args[i][0] + inlist[0][0],
+                                    inlist[0][1], inlist[0][2])
+                    inlist.remove(inlist[0])
+                    added = 1
+                    break
+            if added != 1:
+                self.args.append(inlist[0])
+                inlist.remove(inlist[0])
+        i = 0
+        # This code is to remove empty parts from the list
+        while i < len(self.args):
+            if ((self.args[i][0] == 0) | (self.args[i][1] == 0) |
+                    (self.args[i][2] == 0)):
+                self.args.remove(self.args[i])
+                i -= 1
+            i += 1
+
+    @property
+    def func(self):
+        """Returns the class Dyadic. """
+        return Dyadic
+
+    def __add__(self, other):
+        """The add operator for Dyadic. """
+        other = _check_dyadic(other)
+        return Dyadic(self.args + other.args)
+
+    __radd__ = __add__
+
+    def __mul__(self, other):
+        """Multiplies the Dyadic by a sympifyable expression.
+
+        Parameters
+        ==========
+
+        other : Sympafiable
+            The scalar to multiply this Dyadic with
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, outer
+        >>> N = ReferenceFrame('N')
+        >>> d = outer(N.x, N.x)
+        >>> 5 * d
+        5*(N.x|N.x)
+
+        """
+        newlist = list(self.args)
+        other = sympify(other)
+        for i in range(len(newlist)):
+            newlist[i] = (other * newlist[i][0], newlist[i][1],
+                          newlist[i][2])
+        return Dyadic(newlist)
+
+    __rmul__ = __mul__
+
+    def dot(self, other):
+        """The inner product operator for a Dyadic and a Dyadic or Vector.
+
+        Parameters
+        ==========
+
+        other : Dyadic or Vector
+            The other Dyadic or Vector to take the inner product with
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, outer
+        >>> N = ReferenceFrame('N')
+        >>> D1 = outer(N.x, N.y)
+        >>> D2 = outer(N.y, N.y)
+        >>> D1.dot(D2)
+        (N.x|N.y)
+        >>> D1.dot(N.y)
+        N.x
+
+        """
+        from sympy.physics.vector.vector import Vector, _check_vector
+        if isinstance(other, Dyadic):
+            other = _check_dyadic(other)
+            ol = Dyadic(0)
+            for v in self.args:
+                for v2 in other.args:
+                    ol += v[0] * v2[0] * (v[2].dot(v2[1])) * (v[1].outer(v2[2]))
+        else:
+            other = _check_vector(other)
+            ol = Vector(0)
+            for v in self.args:
+                ol += v[0] * v[1] * (v[2].dot(other))
+        return ol
+
+    # NOTE : supports non-advertised Dyadic & Dyadic, Dyadic & Vector notation
+    __and__ = dot
+
+    def __truediv__(self, other):
+        """Divides the Dyadic by a sympifyable expression. """
+        return self.__mul__(1 / other)
+
+    def __eq__(self, other):
+        """Tests for equality.
+
+        Is currently weak; needs stronger comparison testing
+
+        """
+
+        if other == 0:
+            other = Dyadic(0)
+        other = _check_dyadic(other)
+        if (self.args == []) and (other.args == []):
+            return True
+        elif (self.args == []) or (other.args == []):
+            return False
+        return set(self.args) == set(other.args)
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __neg__(self):
+        return self * -1
+
+    def _latex(self, printer):
+        ar = self.args  # just to shorten things
+        if len(ar) == 0:
+            return str(0)
+        ol = []  # output list, to be concatenated to a string
+        for v in ar:
+            # if the coef of the dyadic is 1, we skip the 1
+            if v[0] == 1:
+                ol.append(' + ' + printer._print(v[1]) + r"\otimes " +
+                          printer._print(v[2]))
+            # if the coef of the dyadic is -1, we skip the 1
+            elif v[0] == -1:
+                ol.append(' - ' +
+                          printer._print(v[1]) +
+                          r"\otimes " +
+                          printer._print(v[2]))
+            # If the coefficient of the dyadic is not 1 or -1,
+            # we might wrap it in parentheses, for readability.
+            elif v[0] != 0:
+                arg_str = printer._print(v[0])
+                if isinstance(v[0], Add):
+                    arg_str = '(%s)' % arg_str
+                if arg_str.startswith('-'):
+                    arg_str = arg_str[1:]
+                    str_start = ' - '
+                else:
+                    str_start = ' + '
+                ol.append(str_start + arg_str + printer._print(v[1]) +
+                          r"\otimes " + printer._print(v[2]))
+        outstr = ''.join(ol)
+        if outstr.startswith(' + '):
+            outstr = outstr[3:]
+        elif outstr.startswith(' '):
+            outstr = outstr[1:]
+        return outstr
+
+    def _pretty(self, printer):
+        e = self
+
+        class Fake:
+            baseline = 0
+
+            def render(self, *args, **kwargs):
+                ar = e.args  # just to shorten things
+                mpp = printer
+                if len(ar) == 0:
+                    return str(0)
+                bar = "\N{CIRCLED TIMES}" if printer._use_unicode else "|"
+                ol = []  # output list, to be concatenated to a string
+                for v in ar:
+                    # if the coef of the dyadic is 1, we skip the 1
+                    if v[0] == 1:
+                        ol.extend([" + ",
+                                  mpp.doprint(v[1]),
+                                  bar,
+                                  mpp.doprint(v[2])])
+
+                    # if the coef of the dyadic is -1, we skip the 1
+                    elif v[0] == -1:
+                        ol.extend([" - ",
+                                  mpp.doprint(v[1]),
+                                  bar,
+                                  mpp.doprint(v[2])])
+
+                    # If the coefficient of the dyadic is not 1 or -1,
+                    # we might wrap it in parentheses, for readability.
+                    elif v[0] != 0:
+                        if isinstance(v[0], Add):
+                            arg_str = mpp._print(
+                                v[0]).parens()[0]
+                        else:
+                            arg_str = mpp.doprint(v[0])
+                        if arg_str.startswith("-"):
+                            arg_str = arg_str[1:]
+                            str_start = " - "
+                        else:
+                            str_start = " + "
+                        ol.extend([str_start, arg_str, " ",
+                                  mpp.doprint(v[1]),
+                                  bar,
+                                  mpp.doprint(v[2])])
+
+                outstr = "".join(ol)
+                if outstr.startswith(" + "):
+                    outstr = outstr[3:]
+                elif outstr.startswith(" "):
+                    outstr = outstr[1:]
+                return outstr
+        return Fake()
+
+    def __rsub__(self, other):
+        return (-1 * self) + other
+
+    def _sympystr(self, printer):
+        """Printing method. """
+        ar = self.args  # just to shorten things
+        if len(ar) == 0:
+            return printer._print(0)
+        ol = []  # output list, to be concatenated to a string
+        for v in ar:
+            # if the coef of the dyadic is 1, we skip the 1
+            if v[0] == 1:
+                ol.append(' + (' + printer._print(v[1]) + '|' +
+                          printer._print(v[2]) + ')')
+            # if the coef of the dyadic is -1, we skip the 1
+            elif v[0] == -1:
+                ol.append(' - (' + printer._print(v[1]) + '|' +
+                          printer._print(v[2]) + ')')
+            # If the coefficient of the dyadic is not 1 or -1,
+            # we might wrap it in parentheses, for readability.
+            elif v[0] != 0:
+                arg_str = printer._print(v[0])
+                if isinstance(v[0], Add):
+                    arg_str = "(%s)" % arg_str
+                if arg_str[0] == '-':
+                    arg_str = arg_str[1:]
+                    str_start = ' - '
+                else:
+                    str_start = ' + '
+                ol.append(str_start + arg_str + '*(' +
+                          printer._print(v[1]) +
+                          '|' + printer._print(v[2]) + ')')
+        outstr = ''.join(ol)
+        if outstr.startswith(' + '):
+            outstr = outstr[3:]
+        elif outstr.startswith(' '):
+            outstr = outstr[1:]
+        return outstr
+
+    def __sub__(self, other):
+        """The subtraction operator. """
+        return self.__add__(other * -1)
+
+    def cross(self, other):
+        """Returns the dyadic resulting from the dyadic vector cross product:
+        Dyadic x Vector.
+
+        Parameters
+        ==========
+        other : Vector
+            Vector to cross with.
+
+        Examples
+        ========
+        >>> from sympy.physics.vector import ReferenceFrame, outer, cross
+        >>> N = ReferenceFrame('N')
+        >>> d = outer(N.x, N.x)
+        >>> cross(d, N.y)
+        (N.x|N.z)
+
+        """
+        from sympy.physics.vector.vector import _check_vector
+        other = _check_vector(other)
+        ol = Dyadic(0)
+        for v in self.args:
+            ol += v[0] * (v[1].outer((v[2].cross(other))))
+        return ol
+
+    # NOTE : supports non-advertised Dyadic ^ Vector notation
+    __xor__ = cross
+
+    def express(self, frame1, frame2=None):
+        """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
+        different frames. If no second frame is given, the Dyadic is
+        expressed in only one frame.
+
+        Calls the global express function
+
+        Parameters
+        ==========
+
+        frame1 : ReferenceFrame
+            The frame to express the left side of the Dyadic in
+        frame2 : ReferenceFrame
+            If provided, the frame to express the right side of the Dyadic in
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, outer, dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> N = ReferenceFrame('N')
+        >>> q = dynamicsymbols('q')
+        >>> B = N.orientnew('B', 'Axis', [q, N.z])
+        >>> d = outer(N.x, N.x)
+        >>> d.express(B, N)
+        cos(q)*(B.x|N.x) - sin(q)*(B.y|N.x)
+
+        """
+        from sympy.physics.vector.functions import express
+        return express(self, frame1, frame2)
+
+    def to_matrix(self, reference_frame, second_reference_frame=None):
+        """Returns the matrix form of the dyadic with respect to one or two
+        reference frames.
+
+        Parameters
+        ----------
+        reference_frame : ReferenceFrame
+            The reference frame that the rows and columns of the matrix
+            correspond to. If a second reference frame is provided, this
+            only corresponds to the rows of the matrix.
+        second_reference_frame : ReferenceFrame, optional, default=None
+            The reference frame that the columns of the matrix correspond
+            to.
+
+        Returns
+        -------
+        matrix : ImmutableMatrix, shape(3,3)
+            The matrix that gives the 2D tensor form.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, trigsimp
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> from sympy.physics.mechanics import inertia
+        >>> Ixx, Iyy, Izz, Ixy, Iyz, Ixz = symbols('Ixx, Iyy, Izz, Ixy, Iyz, Ixz')
+        >>> N = ReferenceFrame('N')
+        >>> inertia_dyadic = inertia(N, Ixx, Iyy, Izz, Ixy, Iyz, Ixz)
+        >>> inertia_dyadic.to_matrix(N)
+        Matrix([
+        [Ixx, Ixy, Ixz],
+        [Ixy, Iyy, Iyz],
+        [Ixz, Iyz, Izz]])
+        >>> beta = symbols('beta')
+        >>> A = N.orientnew('A', 'Axis', (beta, N.x))
+        >>> trigsimp(inertia_dyadic.to_matrix(A))
+        Matrix([
+        [                           Ixx,                                           Ixy*cos(beta) + Ixz*sin(beta),                                           -Ixy*sin(beta) + Ixz*cos(beta)],
+        [ Ixy*cos(beta) + Ixz*sin(beta), Iyy*cos(2*beta)/2 + Iyy/2 + Iyz*sin(2*beta) - Izz*cos(2*beta)/2 + Izz/2,                 -Iyy*sin(2*beta)/2 + Iyz*cos(2*beta) + Izz*sin(2*beta)/2],
+        [-Ixy*sin(beta) + Ixz*cos(beta),                -Iyy*sin(2*beta)/2 + Iyz*cos(2*beta) + Izz*sin(2*beta)/2, -Iyy*cos(2*beta)/2 + Iyy/2 - Iyz*sin(2*beta) + Izz*cos(2*beta)/2 + Izz/2]])
+
+        """
+
+        if second_reference_frame is None:
+            second_reference_frame = reference_frame
+
+        return Matrix([i.dot(self).dot(j) for i in reference_frame for j in
+                      second_reference_frame]).reshape(3, 3)
+
+    def doit(self, **hints):
+        """Calls .doit() on each term in the Dyadic"""
+        return sum([Dyadic([(v[0].doit(**hints), v[1], v[2])])
+                    for v in self.args], Dyadic(0))
+
+    def dt(self, frame):
+        """Take the time derivative of this Dyadic in a frame.
+
+        This function calls the global time_derivative method
+
+        Parameters
+        ==========
+
+        frame : ReferenceFrame
+            The frame to take the time derivative in
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, outer, dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> N = ReferenceFrame('N')
+        >>> q = dynamicsymbols('q')
+        >>> B = N.orientnew('B', 'Axis', [q, N.z])
+        >>> d = outer(N.x, N.x)
+        >>> d.dt(B)
+        - q'*(N.y|N.x) - q'*(N.x|N.y)
+
+        """
+        from sympy.physics.vector.functions import time_derivative
+        return time_derivative(self, frame)
+
+    def simplify(self):
+        """Returns a simplified Dyadic."""
+        out = Dyadic(0)
+        for v in self.args:
+            out += Dyadic([(v[0].simplify(), v[1], v[2])])
+        return out
+
+    def subs(self, *args, **kwargs):
+        """Substitution on the Dyadic.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> from sympy import Symbol
+        >>> N = ReferenceFrame('N')
+        >>> s = Symbol('s')
+        >>> a = s*(N.x|N.x)
+        >>> a.subs({s: 2})
+        2*(N.x|N.x)
+
+        """
+
+        return sum([Dyadic([(v[0].subs(*args, **kwargs), v[1], v[2])])
+                    for v in self.args], Dyadic(0))
+
+    def applyfunc(self, f):
+        """Apply a function to each component of a Dyadic."""
+        if not callable(f):
+            raise TypeError("`f` must be callable.")
+
+        out = Dyadic(0)
+        for a, b, c in self.args:
+            out += f(a) * (b.outer(c))
+        return out
+
+    def _eval_evalf(self, prec):
+        if not self.args:
+            return self
+        new_args = []
+        dps = prec_to_dps(prec)
+        for inlist in self.args:
+            new_inlist = list(inlist)
+            new_inlist[0] = inlist[0].evalf(n=dps)
+            new_args.append(tuple(new_inlist))
+        return Dyadic(new_args)
+
+    def xreplace(self, rule):
+        """
+        Replace occurrences of objects within the measure numbers of the
+        Dyadic.
+
+        Parameters
+        ==========
+
+        rule : dict-like
+            Expresses a replacement rule.
+
+        Returns
+        =======
+
+        Dyadic
+            Result of the replacement.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, pi
+        >>> from sympy.physics.vector import ReferenceFrame, outer
+        >>> N = ReferenceFrame('N')
+        >>> D = outer(N.x, N.x)
+        >>> x, y, z = symbols('x y z')
+        >>> ((1 + x*y) * D).xreplace({x: pi})
+        (pi*y + 1)*(N.x|N.x)
+        >>> ((1 + x*y) * D).xreplace({x: pi, y: 2})
+        (1 + 2*pi)*(N.x|N.x)
+
+        Replacements occur only if an entire node in the expression tree is
+        matched:
+
+        >>> ((x*y + z) * D).xreplace({x*y: pi})
+        (z + pi)*(N.x|N.x)
+        >>> ((x*y*z) * D).xreplace({x*y: pi})
+        x*y*z*(N.x|N.x)
+
+        """
+
+        new_args = []
+        for inlist in self.args:
+            new_inlist = list(inlist)
+            new_inlist[0] = new_inlist[0].xreplace(rule)
+            new_args.append(tuple(new_inlist))
+        return Dyadic(new_args)
+
+
+def _check_dyadic(other):
+    if not isinstance(other, Dyadic):
+        raise TypeError('A Dyadic must be supplied')
+    return other

venv/lib/python3.11/site-packages/sympy/physics/vector/fieldfunctions.py

@@ -0,0 +1,313 @@
+from sympy.core.function import diff
+from sympy.core.singleton import S
+from sympy.integrals.integrals import integrate
+from sympy.physics.vector import Vector, express
+from sympy.physics.vector.frame import _check_frame
+from sympy.physics.vector.vector import _check_vector
+
+
+__all__ = ['curl', 'divergence', 'gradient', 'is_conservative',
+           'is_solenoidal', 'scalar_potential',
+           'scalar_potential_difference']
+
+
+def curl(vect, frame):
+    """
+    Returns the curl of a vector field computed wrt the coordinate
+    symbols of the given frame.
+
+    Parameters
+    ==========
+
+    vect : Vector
+        The vector operand
+
+    frame : ReferenceFrame
+        The reference frame to calculate the curl in
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame
+    >>> from sympy.physics.vector import curl
+    >>> R = ReferenceFrame('R')
+    >>> v1 = R[1]*R[2]*R.x + R[0]*R[2]*R.y + R[0]*R[1]*R.z
+    >>> curl(v1, R)
+    0
+    >>> v2 = R[0]*R[1]*R[2]*R.x
+    >>> curl(v2, R)
+    R_x*R_y*R.y - R_x*R_z*R.z
+
+    """
+
+    _check_vector(vect)
+    if vect == 0:
+        return Vector(0)
+    vect = express(vect, frame, variables=True)
+    # A mechanical approach to avoid looping overheads
+    vectx = vect.dot(frame.x)
+    vecty = vect.dot(frame.y)
+    vectz = vect.dot(frame.z)
+    outvec = Vector(0)
+    outvec += (diff(vectz, frame[1]) - diff(vecty, frame[2])) * frame.x
+    outvec += (diff(vectx, frame[2]) - diff(vectz, frame[0])) * frame.y
+    outvec += (diff(vecty, frame[0]) - diff(vectx, frame[1])) * frame.z
+    return outvec
+
+
+def divergence(vect, frame):
+    """
+    Returns the divergence of a vector field computed wrt the coordinate
+    symbols of the given frame.
+
+    Parameters
+    ==========
+
+    vect : Vector
+        The vector operand
+
+    frame : ReferenceFrame
+        The reference frame to calculate the divergence in
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame
+    >>> from sympy.physics.vector import divergence
+    >>> R = ReferenceFrame('R')
+    >>> v1 = R[0]*R[1]*R[2] * (R.x+R.y+R.z)
+    >>> divergence(v1, R)
+    R_x*R_y + R_x*R_z + R_y*R_z
+    >>> v2 = 2*R[1]*R[2]*R.y
+    >>> divergence(v2, R)
+    2*R_z
+
+    """
+
+    _check_vector(vect)
+    if vect == 0:
+        return S.Zero
+    vect = express(vect, frame, variables=True)
+    vectx = vect.dot(frame.x)
+    vecty = vect.dot(frame.y)
+    vectz = vect.dot(frame.z)
+    out = S.Zero
+    out += diff(vectx, frame[0])
+    out += diff(vecty, frame[1])
+    out += diff(vectz, frame[2])
+    return out
+
+
+def gradient(scalar, frame):
+    """
+    Returns the vector gradient of a scalar field computed wrt the
+    coordinate symbols of the given frame.
+
+    Parameters
+    ==========
+
+    scalar : sympifiable
+        The scalar field to take the gradient of
+
+    frame : ReferenceFrame
+        The frame to calculate the gradient in
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame
+    >>> from sympy.physics.vector import gradient
+    >>> R = ReferenceFrame('R')
+    >>> s1 = R[0]*R[1]*R[2]
+    >>> gradient(s1, R)
+    R_y*R_z*R.x + R_x*R_z*R.y + R_x*R_y*R.z
+    >>> s2 = 5*R[0]**2*R[2]
+    >>> gradient(s2, R)
+    10*R_x*R_z*R.x + 5*R_x**2*R.z
+
+    """
+
+    _check_frame(frame)
+    outvec = Vector(0)
+    scalar = express(scalar, frame, variables=True)
+    for i, x in enumerate(frame):
+        outvec += diff(scalar, frame[i]) * x  # noqa: PLR1736
+    return outvec
+
+
+def is_conservative(field):
+    """
+    Checks if a field is conservative.
+
+    Parameters
+    ==========
+
+    field : Vector
+        The field to check for conservative property
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame
+    >>> from sympy.physics.vector import is_conservative
+    >>> R = ReferenceFrame('R')
+    >>> is_conservative(R[1]*R[2]*R.x + R[0]*R[2]*R.y + R[0]*R[1]*R.z)
+    True
+    >>> is_conservative(R[2] * R.y)
+    False
+
+    """
+
+    # Field is conservative irrespective of frame
+    # Take the first frame in the result of the separate method of Vector
+    if field == Vector(0):
+        return True
+    frame = list(field.separate())[0]
+    return curl(field, frame).simplify() == Vector(0)
+
+
+def is_solenoidal(field):
+    """
+    Checks if a field is solenoidal.
+
+    Parameters
+    ==========
+
+    field : Vector
+        The field to check for solenoidal property
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame
+    >>> from sympy.physics.vector import is_solenoidal
+    >>> R = ReferenceFrame('R')
+    >>> is_solenoidal(R[1]*R[2]*R.x + R[0]*R[2]*R.y + R[0]*R[1]*R.z)
+    True
+    >>> is_solenoidal(R[1] * R.y)
+    False
+
+    """
+
+    # Field is solenoidal irrespective of frame
+    # Take the first frame in the result of the separate method in Vector
+    if field == Vector(0):
+        return True
+    frame = list(field.separate())[0]
+    return divergence(field, frame).simplify() is S.Zero
+
+
+def scalar_potential(field, frame):
+    """
+    Returns the scalar potential function of a field in a given frame
+    (without the added integration constant).
+
+    Parameters
+    ==========
+
+    field : Vector
+        The vector field whose scalar potential function is to be
+        calculated
+
+    frame : ReferenceFrame
+        The frame to do the calculation in
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame
+    >>> from sympy.physics.vector import scalar_potential, gradient
+    >>> R = ReferenceFrame('R')
+    >>> scalar_potential(R.z, R) == R[2]
+    True
+    >>> scalar_field = 2*R[0]**2*R[1]*R[2]
+    >>> grad_field = gradient(scalar_field, R)
+    >>> scalar_potential(grad_field, R)
+    2*R_x**2*R_y*R_z
+
+    """
+
+    # Check whether field is conservative
+    if not is_conservative(field):
+        raise ValueError("Field is not conservative")
+    if field == Vector(0):
+        return S.Zero
+    # Express the field exntirely in frame
+    # Substitute coordinate variables also
+    _check_frame(frame)
+    field = express(field, frame, variables=True)
+    # Make a list of dimensions of the frame
+    dimensions = list(frame)
+    # Calculate scalar potential function
+    temp_function = integrate(field.dot(dimensions[0]), frame[0])
+    for i, dim in enumerate(dimensions[1:]):
+        partial_diff = diff(temp_function, frame[i + 1])
+        partial_diff = field.dot(dim) - partial_diff
+        temp_function += integrate(partial_diff, frame[i + 1])
+    return temp_function
+
+
+def scalar_potential_difference(field, frame, point1, point2, origin):
+    """
+    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
+    considered. If a conservative vector field is provided, the values
+    of its scalar potential function at the two points are used.
+
+    Returns (potential at position 2) - (potential at position 1)
+
+    Parameters
+    ==========
+
+    field : Vector/sympyfiable
+        The field to calculate wrt
+
+    frame : ReferenceFrame
+        The frame to do the calculations in
+
+    point1 : Point
+        The initial Point in given frame
+
+    position2 : Point
+        The second Point in the given frame
+
+    origin : Point
+        The Point to use as reference point for position vector
+        calculation
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame, Point
+    >>> from sympy.physics.vector import scalar_potential_difference
+    >>> R = ReferenceFrame('R')
+    >>> O = Point('O')
+    >>> P = O.locatenew('P', R[0]*R.x + R[1]*R.y + R[2]*R.z)
+    >>> vectfield = 4*R[0]*R[1]*R.x + 2*R[0]**2*R.y
+    >>> scalar_potential_difference(vectfield, R, O, P, O)
+    2*R_x**2*R_y
+    >>> Q = O.locatenew('O', 3*R.x + R.y + 2*R.z)
+    >>> scalar_potential_difference(vectfield, R, P, Q, O)
+    -2*R_x**2*R_y + 18
+
+    """
+
+    _check_frame(frame)
+    if isinstance(field, Vector):
+        # Get the scalar potential function
+        scalar_fn = scalar_potential(field, frame)
+    else:
+        # Field is a scalar
+        scalar_fn = field
+    # Express positions in required frame
+    position1 = express(point1.pos_from(origin), frame, variables=True)
+    position2 = express(point2.pos_from(origin), frame, variables=True)
+    # Get the two positions as substitution dicts for coordinate variables
+    subs_dict1 = {}
+    subs_dict2 = {}
+    for i, x in enumerate(frame):
+        subs_dict1[frame[i]] = x.dot(position1)
+        subs_dict2[frame[i]] = x.dot(position2)
+    return scalar_fn.subs(subs_dict2) - scalar_fn.subs(subs_dict1)

venv/lib/python3.11/site-packages/sympy/physics/vector/frame.py

@@ -0,0 +1,1575 @@
+from sympy import (diff, expand, sin, cos, sympify, eye, zeros,
+                                ImmutableMatrix as Matrix, MatrixBase)
+from sympy.core.symbol import Symbol
+from sympy.simplify.trigsimp import trigsimp
+from sympy.physics.vector.vector import Vector, _check_vector
+from sympy.utilities.misc import translate
+
+from warnings import warn
+
+__all__ = ['CoordinateSym', 'ReferenceFrame']
+
+
+class CoordinateSym(Symbol):
+    """
+    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
+    as 'frame[index]'.
+
+    CoordinateSyms having the same frame and index parameters are equal
+    (even though they may be instantiated separately).
+
+    Parameters
+    ==========
+
+    name : string
+        The display name of the CoordinateSym
+
+    frame : ReferenceFrame
+        The reference frame this base scalar belongs to
+
+    index : 0, 1 or 2
+        The index of the dimension denoted by this coordinate variable
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame, CoordinateSym
+    >>> A = ReferenceFrame('A')
+    >>> A[1]
+    A_y
+    >>> type(A[0])
+    <class 'sympy.physics.vector.frame.CoordinateSym'>
+    >>> a_y = CoordinateSym('a_y', A, 1)
+    >>> a_y == A[1]
+    True
+
+    """
+
+    def __new__(cls, name, frame, index):
+        # We can't use the cached Symbol.__new__ because this class depends on
+        # frame and index, which are not passed to Symbol.__xnew__.
+        assumptions = {}
+        super()._sanitize(assumptions, cls)
+        obj = super().__xnew__(cls, name, **assumptions)
+        _check_frame(frame)
+        if index not in range(0, 3):
+            raise ValueError("Invalid index specified")
+        obj._id = (frame, index)
+        return obj
+
+    def __getnewargs_ex__(self):
+        return (self.name, *self._id), {}
+
+    @property
+    def frame(self):
+        return self._id[0]
+
+    def __eq__(self, other):
+        # Check if the other object is a CoordinateSym of the same frame and
+        # same index
+        if isinstance(other, CoordinateSym):
+            if other._id == self._id:
+                return True
+        return False
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __hash__(self):
+        return (self._id[0].__hash__(), self._id[1]).__hash__()
+
+
+class ReferenceFrame:
+    """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
+    x, y, and z directions.
+
+    It also can have a rotation relative to a parent frame; this rotation is
+    defined by a direction cosine matrix relating this frame's basis vectors to
+    the parent frame's basis vectors.  It can also have an angular velocity
+    vector, defined in another frame.
+
+    """
+    _count = 0
+
+    def __init__(self, name, indices=None, latexs=None, variables=None):
+        """ReferenceFrame initialization method.
+
+        A ReferenceFrame has a set of orthonormal basis vectors, along with
+        orientations relative to other ReferenceFrames and angular velocities
+        relative to other ReferenceFrames.
+
+        Parameters
+        ==========
+
+        indices : tuple of str
+            Enables the reference frame's basis unit vectors to be accessed by
+            Python's square bracket indexing notation using the provided three
+            indice strings and alters the printing of the unit vectors to
+            reflect this choice.
+        latexs : tuple of str
+            Alters the LaTeX printing of the reference frame's basis unit
+            vectors to the provided three valid LaTeX strings.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, vlatex
+        >>> N = ReferenceFrame('N')
+        >>> N.x
+        N.x
+        >>> O = ReferenceFrame('O', indices=('1', '2', '3'))
+        >>> O.x
+        O['1']
+        >>> O['1']
+        O['1']
+        >>> P = ReferenceFrame('P', latexs=('A1', 'A2', 'A3'))
+        >>> vlatex(P.x)
+        'A1'
+
+        ``symbols()`` can be used to create multiple Reference Frames in one
+        step, for example:
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> from sympy import symbols
+        >>> A, B, C = symbols('A B C', cls=ReferenceFrame)
+        >>> D, E = symbols('D E', cls=ReferenceFrame, indices=('1', '2', '3'))
+        >>> A[0]
+        A_x
+        >>> D.x
+        D['1']
+        >>> E.y
+        E['2']
+        >>> type(A) == type(D)
+        True
+
+        Unit dyads for the ReferenceFrame can be accessed through the attributes ``xx``, ``xy``, etc. For example:
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> N.yz
+        (N.y|N.z)
+        >>> N.zx
+        (N.z|N.x)
+        >>> P = ReferenceFrame('P', indices=['1', '2', '3'])
+        >>> P.xx
+        (P['1']|P['1'])
+        >>> P.zy
+        (P['3']|P['2'])
+
+        Unit dyadic is also accessible via the ``u`` attribute:
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> N.u
+        (N.x|N.x) + (N.y|N.y) + (N.z|N.z)
+        >>> P = ReferenceFrame('P', indices=['1', '2', '3'])
+        >>> P.u
+        (P['1']|P['1']) + (P['2']|P['2']) + (P['3']|P['3'])
+
+        """
+
+        if not isinstance(name, str):
+            raise TypeError('Need to supply a valid name')
+        # The if statements below are for custom printing of basis-vectors for
+        # each frame.
+        # First case, when custom indices are supplied
+        if indices is not None:
+            if not isinstance(indices, (tuple, list)):
+                raise TypeError('Supply the indices as a list')
+            if len(indices) != 3:
+                raise ValueError('Supply 3 indices')
+            for i in indices:
+                if not isinstance(i, str):
+                    raise TypeError('Indices must be strings')
+            self.str_vecs = [(name + '[\'' + indices[0] + '\']'),
+                             (name + '[\'' + indices[1] + '\']'),
+                             (name + '[\'' + indices[2] + '\']')]
+            self.pretty_vecs = [(name.lower() + "_" + indices[0]),
+                                (name.lower() + "_" + indices[1]),
+                                (name.lower() + "_" + indices[2])]
+            self.latex_vecs = [(r"\mathbf{\hat{%s}_{%s}}" % (name.lower(),
+                                                             indices[0])),
+                               (r"\mathbf{\hat{%s}_{%s}}" % (name.lower(),
+                                                             indices[1])),
+                               (r"\mathbf{\hat{%s}_{%s}}" % (name.lower(),
+                                                             indices[2]))]
+            self.indices = indices
+        # Second case, when no custom indices are supplied
+        else:
+            self.str_vecs = [(name + '.x'), (name + '.y'), (name + '.z')]
+            self.pretty_vecs = [name.lower() + "_x",
+                                name.lower() + "_y",
+                                name.lower() + "_z"]
+            self.latex_vecs = [(r"\mathbf{\hat{%s}_x}" % name.lower()),
+                               (r"\mathbf{\hat{%s}_y}" % name.lower()),
+                               (r"\mathbf{\hat{%s}_z}" % name.lower())]
+            self.indices = ['x', 'y', 'z']
+        # Different step, for custom latex basis vectors
+        if latexs is not None:
+            if not isinstance(latexs, (tuple, list)):
+                raise TypeError('Supply the indices as a list')
+            if len(latexs) != 3:
+                raise ValueError('Supply 3 indices')
+            for i in latexs:
+                if not isinstance(i, str):
+                    raise TypeError('Latex entries must be strings')
+            self.latex_vecs = latexs
+        self.name = name
+        self._var_dict = {}
+        # The _dcm_dict dictionary will only store the dcms of adjacent
+        # parent-child relationships. The _dcm_cache dictionary will store
+        # calculated dcm along with all content of _dcm_dict for faster
+        # retrieval of dcms.
+        self._dcm_dict = {}
+        self._dcm_cache = {}
+        self._ang_vel_dict = {}
+        self._ang_acc_dict = {}
+        self._dlist = [self._dcm_dict, self._ang_vel_dict, self._ang_acc_dict]
+        self._cur = 0
+        self._x = Vector([(Matrix([1, 0, 0]), self)])
+        self._y = Vector([(Matrix([0, 1, 0]), self)])
+        self._z = Vector([(Matrix([0, 0, 1]), self)])
+        # Associate coordinate symbols wrt this frame
+        if variables is not None:
+            if not isinstance(variables, (tuple, list)):
+                raise TypeError('Supply the variable names as a list/tuple')
+            if len(variables) != 3:
+                raise ValueError('Supply 3 variable names')
+            for i in variables:
+                if not isinstance(i, str):
+                    raise TypeError('Variable names must be strings')
+        else:
+            variables = [name + '_x', name + '_y', name + '_z']
+        self.varlist = (CoordinateSym(variables[0], self, 0),
+                        CoordinateSym(variables[1], self, 1),
+                        CoordinateSym(variables[2], self, 2))
+        ReferenceFrame._count += 1
+        self.index = ReferenceFrame._count
+
+    def __getitem__(self, ind):
+        """
+        Returns basis vector for the provided index, if the index is a string.
+
+        If the index is a number, returns the coordinate variable correspon-
+        -ding to that index.
+        """
+        if not isinstance(ind, str):
+            if ind < 3:
+                return self.varlist[ind]
+            else:
+                raise ValueError("Invalid index provided")
+        if self.indices[0] == ind:
+            return self.x
+        if self.indices[1] == ind:
+            return self.y
+        if self.indices[2] == ind:
+            return self.z
+        else:
+            raise ValueError('Not a defined index')
+
+    def __iter__(self):
+        return iter([self.x, self.y, self.z])
+
+    def __str__(self):
+        """Returns the name of the frame. """
+        return self.name
+
+    __repr__ = __str__
+
+    def _dict_list(self, other, num):
+        """Returns an inclusive list of reference frames that connect this
+        reference frame to the provided reference frame.
+
+        Parameters
+        ==========
+        other : ReferenceFrame
+            The other reference frame to look for a connecting relationship to.
+        num : integer
+            ``0``, ``1``, and ``2`` will look for orientation, angular
+            velocity, and angular acceleration relationships between the two
+            frames, respectively.
+
+        Returns
+        =======
+        list
+            Inclusive list of reference frames that connect this reference
+            frame to the other reference frame.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> A = ReferenceFrame('A')
+        >>> B = ReferenceFrame('B')
+        >>> C = ReferenceFrame('C')
+        >>> D = ReferenceFrame('D')
+        >>> B.orient_axis(A, A.x, 1.0)
+        >>> C.orient_axis(B, B.x, 1.0)
+        >>> D.orient_axis(C, C.x, 1.0)
+        >>> D._dict_list(A, 0)
+        [D, C, B, A]
+
+        Raises
+        ======
+
+        ValueError
+            When no path is found between the two reference frames or ``num``
+            is an incorrect value.
+
+        """
+
+        connect_type = {0: 'orientation',
+                        1: 'angular velocity',
+                        2: 'angular acceleration'}
+
+        if num not in connect_type.keys():
+            raise ValueError('Valid values for num are 0, 1, or 2.')
+
+        possible_connecting_paths = [[self]]
+        oldlist = [[]]
+        while possible_connecting_paths != oldlist:
+            oldlist = possible_connecting_paths.copy()
+            for frame_list in possible_connecting_paths:
+                frames_adjacent_to_last = frame_list[-1]._dlist[num].keys()
+                for adjacent_frame in frames_adjacent_to_last:
+                    if adjacent_frame not in frame_list:
+                        connecting_path = frame_list + [adjacent_frame]
+                        if connecting_path not in possible_connecting_paths:
+                            possible_connecting_paths.append(connecting_path)
+
+        for connecting_path in oldlist:
+            if connecting_path[-1] != other:
+                possible_connecting_paths.remove(connecting_path)
+        possible_connecting_paths.sort(key=len)
+
+        if len(possible_connecting_paths) != 0:
+            return possible_connecting_paths[0]  # selects the shortest path
+
+        msg = 'No connecting {} path found between {} and {}.'
+        raise ValueError(msg.format(connect_type[num], self.name, other.name))
+
+    def _w_diff_dcm(self, otherframe):
+        """Angular velocity from time differentiating the DCM. """
+        from sympy.physics.vector.functions import dynamicsymbols
+        dcm2diff = otherframe.dcm(self)
+        diffed = dcm2diff.diff(dynamicsymbols._t)
+        angvelmat = diffed * dcm2diff.T
+        w1 = trigsimp(expand(angvelmat[7]), recursive=True)
+        w2 = trigsimp(expand(angvelmat[2]), recursive=True)
+        w3 = trigsimp(expand(angvelmat[3]), recursive=True)
+        return Vector([(Matrix([w1, w2, w3]), otherframe)])
+
+    def variable_map(self, otherframe):
+        """
+        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
+        values. Else, returns them without simplification.
+
+        Simplification of the expressions may take time.
+
+        Parameters
+        ==========
+
+        otherframe : ReferenceFrame
+            The other frame to map the variables to
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, dynamicsymbols
+        >>> A = ReferenceFrame('A')
+        >>> q = dynamicsymbols('q')
+        >>> B = A.orientnew('B', 'Axis', [q, A.z])
+        >>> A.variable_map(B)
+        {A_x: B_x*cos(q(t)) - B_y*sin(q(t)), A_y: B_x*sin(q(t)) + B_y*cos(q(t)), A_z: B_z}
+
+        """
+
+        _check_frame(otherframe)
+        if (otherframe, Vector.simp) in self._var_dict:
+            return self._var_dict[(otherframe, Vector.simp)]
+        else:
+            vars_matrix = self.dcm(otherframe) * Matrix(otherframe.varlist)
+            mapping = {}
+            for i, x in enumerate(self):
+                if Vector.simp:
+                    mapping[self.varlist[i]] = trigsimp(vars_matrix[i],
+                                                        method='fu')
+                else:
+                    mapping[self.varlist[i]] = vars_matrix[i]
+            self._var_dict[(otherframe, Vector.simp)] = mapping
+            return mapping
+
+    def ang_acc_in(self, otherframe):
+        """Returns the angular acceleration Vector of the ReferenceFrame.
+
+        Effectively returns the Vector:
+
+        ``N_alpha_B``
+
+        which represent the angular acceleration of B in N, where B is self,
+        and N is otherframe.
+
+        Parameters
+        ==========
+
+        otherframe : ReferenceFrame
+            The ReferenceFrame which the angular acceleration is returned in.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> A = ReferenceFrame('A')
+        >>> V = 10 * N.x
+        >>> A.set_ang_acc(N, V)
+        >>> A.ang_acc_in(N)
+        10*N.x
+
+        """
+
+        _check_frame(otherframe)
+        if otherframe in self._ang_acc_dict:
+            return self._ang_acc_dict[otherframe]
+        else:
+            return self.ang_vel_in(otherframe).dt(otherframe)
+
+    def ang_vel_in(self, otherframe):
+        """Returns the angular velocity Vector of the ReferenceFrame.
+
+        Effectively returns the Vector:
+
+        ^N omega ^B
+
+        which represent the angular velocity of B in N, where B is self, and
+        N is otherframe.
+
+        Parameters
+        ==========
+
+        otherframe : ReferenceFrame
+            The ReferenceFrame which the angular velocity is returned in.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> A = ReferenceFrame('A')
+        >>> V = 10 * N.x
+        >>> A.set_ang_vel(N, V)
+        >>> A.ang_vel_in(N)
+        10*N.x
+
+        """
+
+        _check_frame(otherframe)
+        flist = self._dict_list(otherframe, 1)
+        outvec = Vector(0)
+        for i in range(len(flist) - 1):
+            outvec += flist[i]._ang_vel_dict[flist[i + 1]]
+        return outvec
+
+    def dcm(self, otherframe):
+        r"""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
+        of this frame in terms of the orthogonal unit vectors of
+        ``otherframe``.
+
+        Parameters
+        ==========
+
+        otherframe : ReferenceFrame
+            The reference frame which the direction cosine matrix of this frame
+            is formed relative to.
+
+        Examples
+        ========
+
+        The following example rotates the reference frame A relative to N by a
+        simple rotation and then calculates the direction cosine matrix of N
+        relative to A.
+
+        >>> from sympy import symbols, sin, cos
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> q1 = symbols('q1')
+        >>> N = ReferenceFrame('N')
+        >>> A = ReferenceFrame('A')
+        >>> A.orient_axis(N, q1, N.x)
+        >>> N.dcm(A)
+        Matrix([
+        [1,       0,        0],
+        [0, cos(q1), -sin(q1)],
+        [0, sin(q1),  cos(q1)]])
+
+        The second row of the above direction cosine matrix represents the
+        ``N.y`` unit vector in N expressed in A. Like so:
+
+        >>> Ny = 0*A.x + cos(q1)*A.y - sin(q1)*A.z
+
+        Thus, expressing ``N.y`` in A should return the same result:
+
+        >>> N.y.express(A)
+        cos(q1)*A.y - sin(q1)*A.z
+
+        Notes
+        =====
+
+        It is important to know what form of the direction cosine matrix is
+        returned. If ``B.dcm(A)`` is called, it means the "direction cosine
+        matrix of B rotated relative to A". This is the matrix
+        :math:`{}^B\mathbf{C}^A` shown in the following relationship:
+
+        .. math::
+
+           \begin{bmatrix}
+             \hat{\mathbf{b}}_1 \\
+             \hat{\mathbf{b}}_2 \\
+             \hat{\mathbf{b}}_3
+           \end{bmatrix}
+           =
+           {}^B\mathbf{C}^A
+           \begin{bmatrix}
+             \hat{\mathbf{a}}_1 \\
+             \hat{\mathbf{a}}_2 \\
+             \hat{\mathbf{a}}_3
+           \end{bmatrix}.
+
+        :math:`{}^B\mathbf{C}^A` is the matrix that expresses the B unit
+        vectors in terms of the A unit vectors.
+
+        """
+
+        _check_frame(otherframe)
+        # Check if the dcm wrt that frame has already been calculated
+        if otherframe in self._dcm_cache:
+            return self._dcm_cache[otherframe]
+        flist = self._dict_list(otherframe, 0)
+        outdcm = eye(3)
+        for i in range(len(flist) - 1):
+            outdcm = outdcm * flist[i]._dcm_dict[flist[i + 1]]
+        # After calculation, store the dcm in dcm cache for faster future
+        # retrieval
+        self._dcm_cache[otherframe] = outdcm
+        otherframe._dcm_cache[self] = outdcm.T
+        return outdcm
+
+    def _dcm(self, parent, parent_orient):
+        # If parent.oreint(self) is already defined,then
+        # update the _dcm_dict of parent while over write
+        # all content of self._dcm_dict and self._dcm_cache
+        # with new dcm relation.
+        # Else update _dcm_cache and _dcm_dict of both
+        # self and parent.
+        frames = self._dcm_cache.keys()
+        dcm_dict_del = []
+        dcm_cache_del = []
+        if parent in frames:
+            for frame in frames:
+                if frame in self._dcm_dict:
+                    dcm_dict_del += [frame]
+                dcm_cache_del += [frame]
+            # Reset the _dcm_cache of this frame, and remove it from the
+            # _dcm_caches of the frames it is linked to. Also remove it from
+            # the _dcm_dict of its parent
+            for frame in dcm_dict_del:
+                del frame._dcm_dict[self]
+            for frame in dcm_cache_del:
+                del frame._dcm_cache[self]
+        # Reset the _dcm_dict
+            self._dcm_dict = self._dlist[0] = {}
+        # Reset the _dcm_cache
+            self._dcm_cache = {}
+
+        else:
+            # Check for loops and raise warning accordingly.
+            visited = []
+            queue = list(frames)
+            cont = True  # Flag to control queue loop.
+            while queue and cont:
+                node = queue.pop(0)
+                if node not in visited:
+                    visited.append(node)
+                    neighbors = node._dcm_dict.keys()
+                    for neighbor in neighbors:
+                        if neighbor == parent:
+                            warn('Loops are defined among the orientation of '
+                                 'frames. This is likely not desired and may '
+                                 'cause errors in your calculations.')
+                            cont = False
+                            break
+                        queue.append(neighbor)
+
+        # Add the dcm relationship to _dcm_dict
+        self._dcm_dict.update({parent: parent_orient.T})
+        parent._dcm_dict.update({self: parent_orient})
+        # Update the dcm cache
+        self._dcm_cache.update({parent: parent_orient.T})
+        parent._dcm_cache.update({self: parent_orient})
+
+    def orient_axis(self, parent, axis, angle):
+        """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.
+
+        Parameters
+        ==========
+
+        parent : ReferenceFrame
+            Reference frame that this reference frame will be rotated relative
+            to.
+        axis : Vector
+            Vector fixed in the parent frame about about which this frame is
+            rotated. It need not be a unit vector and the rotation follows the
+            right hand rule.
+        angle : sympifiable
+            Angle in radians by which it the frame is to be rotated.
+
+        Warns
+        ======
+
+        UserWarning
+            If the orientation creates a kinematic loop.
+
+        Examples
+        ========
+
+        Setup variables for the examples:
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> q1 = symbols('q1')
+        >>> N = ReferenceFrame('N')
+        >>> B = ReferenceFrame('B')
+        >>> B.orient_axis(N, N.x, q1)
+
+        The ``orient_axis()`` method generates a direction cosine matrix and
+        its transpose which defines the orientation of B relative to N and vice
+        versa. Once orient is called, ``dcm()`` outputs the appropriate
+        direction cosine matrix:
+
+        >>> B.dcm(N)
+        Matrix([
+        [1,       0,      0],
+        [0,  cos(q1), sin(q1)],
+        [0, -sin(q1), cos(q1)]])
+        >>> N.dcm(B)
+        Matrix([
+        [1,       0,        0],
+        [0, cos(q1), -sin(q1)],
+        [0, sin(q1),  cos(q1)]])
+
+        The following two lines show that the sense of the rotation can be
+        defined by negating the vector direction or the angle. Both lines
+        produce the same result.
+
+        >>> B.orient_axis(N, -N.x, q1)
+        >>> B.orient_axis(N, N.x, -q1)
+
+        """
+
+        from sympy.physics.vector.functions import dynamicsymbols
+        _check_frame(parent)
+
+        if not isinstance(axis, Vector) and isinstance(angle, Vector):
+            axis, angle = angle, axis
+
+        axis = _check_vector(axis)
+        theta = sympify(angle)
+
+        if not axis.dt(parent) == 0:
+            raise ValueError('Axis cannot be time-varying.')
+        unit_axis = axis.express(parent).normalize()
+        unit_col = unit_axis.args[0][0]
+        parent_orient_axis = (
+            (eye(3) - unit_col * unit_col.T) * cos(theta) +
+            Matrix([[0, -unit_col[2], unit_col[1]],
+                    [unit_col[2], 0, -unit_col[0]],
+                    [-unit_col[1], unit_col[0], 0]]) *
+            sin(theta) + unit_col * unit_col.T)
+
+        self._dcm(parent, parent_orient_axis)
+
+        thetad = (theta).diff(dynamicsymbols._t)
+        wvec = thetad*axis.express(parent).normalize()
+        self._ang_vel_dict.update({parent: wvec})
+        parent._ang_vel_dict.update({self: -wvec})
+        self._var_dict = {}
+
+    def orient_explicit(self, parent, dcm):
+        """Sets the orientation of this reference frame relative to another (parent) reference frame
+        using a direction cosine matrix that describes the rotation from the parent to the child.
+
+        Parameters
+        ==========
+
+        parent : ReferenceFrame
+            Reference frame that this reference frame will be rotated relative
+            to.
+        dcm : Matrix, shape(3, 3)
+            Direction cosine matrix that specifies the relative rotation
+            between the two reference frames.
+
+        Warns
+        ======
+
+        UserWarning
+            If the orientation creates a kinematic loop.
+
+        Examples
+        ========
+
+        Setup variables for the examples:
+
+        >>> from sympy import symbols, Matrix, sin, cos
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> q1 = symbols('q1')
+        >>> A = ReferenceFrame('A')
+        >>> B = ReferenceFrame('B')
+        >>> N = ReferenceFrame('N')
+
+        A simple rotation of ``A`` relative to ``N`` about ``N.x`` is defined
+        by the following direction cosine matrix:
+
+        >>> dcm = Matrix([[1, 0, 0],
+        ...               [0, cos(q1), -sin(q1)],
+        ...               [0, sin(q1), cos(q1)]])
+        >>> A.orient_explicit(N, dcm)
+        >>> A.dcm(N)
+        Matrix([
+        [1,       0,      0],
+        [0,  cos(q1), sin(q1)],
+        [0, -sin(q1), cos(q1)]])
+
+        This is equivalent to using ``orient_axis()``:
+
+        >>> B.orient_axis(N, N.x, q1)
+        >>> B.dcm(N)
+        Matrix([
+        [1,       0,      0],
+        [0,  cos(q1), sin(q1)],
+        [0, -sin(q1), cos(q1)]])
+
+        **Note carefully that** ``N.dcm(B)`` **(the transpose) would be passed
+        into** ``orient_explicit()`` **for** ``A.dcm(N)`` **to match**
+        ``B.dcm(N)``:
+
+        >>> A.orient_explicit(N, N.dcm(B))
+        >>> A.dcm(N)
+        Matrix([
+        [1,       0,      0],
+        [0,  cos(q1), sin(q1)],
+        [0, -sin(q1), cos(q1)]])
+
+        """
+        _check_frame(parent)
+        # amounts must be a Matrix type object
+        # (e.g. sympy.matrices.dense.MutableDenseMatrix).
+        if not isinstance(dcm, MatrixBase):
+            raise TypeError("Amounts must be a SymPy Matrix type object.")
+
+        self.orient_dcm(parent, dcm.T)
+
+    def orient_dcm(self, parent, dcm):
+        """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.
+
+        Parameters
+        ==========
+
+        parent : ReferenceFrame
+            Reference frame that this reference frame will be rotated relative
+            to.
+        dcm : Matrix, shape(3, 3)
+            Direction cosine matrix that specifies the relative rotation
+            between the two reference frames.
+
+        Warns
+        ======
+
+        UserWarning
+            If the orientation creates a kinematic loop.
+
+        Examples
+        ========
+
+        Setup variables for the examples:
+
+        >>> from sympy import symbols, Matrix, sin, cos
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> q1 = symbols('q1')
+        >>> A = ReferenceFrame('A')
+        >>> B = ReferenceFrame('B')
+        >>> N = ReferenceFrame('N')
+
+        A simple rotation of ``A`` relative to ``N`` about ``N.x`` is defined
+        by the following direction cosine matrix:
+
+        >>> dcm = Matrix([[1, 0, 0],
+        ...               [0,  cos(q1), sin(q1)],
+        ...               [0, -sin(q1), cos(q1)]])
+        >>> A.orient_dcm(N, dcm)
+        >>> A.dcm(N)
+        Matrix([
+        [1,       0,      0],
+        [0,  cos(q1), sin(q1)],
+        [0, -sin(q1), cos(q1)]])
+
+        This is equivalent to using ``orient_axis()``:
+
+        >>> B.orient_axis(N, N.x, q1)
+        >>> B.dcm(N)
+        Matrix([
+        [1,       0,      0],
+        [0,  cos(q1), sin(q1)],
+        [0, -sin(q1), cos(q1)]])
+
+        """
+
+        _check_frame(parent)
+        # amounts must be a Matrix type object
+        # (e.g. sympy.matrices.dense.MutableDenseMatrix).
+        if not isinstance(dcm, MatrixBase):
+            raise TypeError("Amounts must be a SymPy Matrix type object.")
+
+        self._dcm(parent, dcm.T)
+
+        wvec = self._w_diff_dcm(parent)
+        self._ang_vel_dict.update({parent: wvec})
+        parent._ang_vel_dict.update({self: -wvec})
+        self._var_dict = {}
+
+    def _rot(self, axis, angle):
+        """DCM for simple axis 1,2,or 3 rotations."""
+        if axis == 1:
+            return Matrix([[1, 0, 0],
+                           [0, cos(angle), -sin(angle)],
+                           [0, sin(angle), cos(angle)]])
+        elif axis == 2:
+            return Matrix([[cos(angle), 0, sin(angle)],
+                           [0, 1, 0],
+                           [-sin(angle), 0, cos(angle)]])
+        elif axis == 3:
+            return Matrix([[cos(angle), -sin(angle), 0],
+                           [sin(angle), cos(angle), 0],
+                           [0, 0, 1]])
+
+    def _parse_consecutive_rotations(self, angles, rotation_order):
+        """Helper for orient_body_fixed and orient_space_fixed.
+
+        Parameters
+        ==========
+        angles : 3-tuple of sympifiable
+            Three angles in radians used for the successive rotations.
+        rotation_order : 3 character string or 3 digit integer
+            Order of the rotations. The order can be specified by the strings
+            ``'XZX'``, ``'131'``, or the integer ``131``. There are 12 unique
+            valid rotation orders.
+
+        Returns
+        =======
+
+        amounts : list
+            List of sympifiables corresponding to the rotation angles.
+        rot_order : list
+            List of integers corresponding to the axis of rotation.
+        rot_matrices : list
+            List of DCM around the given axis with corresponding magnitude.
+
+        """
+        amounts = list(angles)
+        for i, v in enumerate(amounts):
+            if not isinstance(v, Vector):
+                amounts[i] = sympify(v)
+
+        approved_orders = ('123', '231', '312', '132', '213', '321', '121',
+                           '131', '212', '232', '313', '323', '')
+        # make sure XYZ => 123
+        rot_order = translate(str(rotation_order), 'XYZxyz', '123123')
+        if rot_order not in approved_orders:
+            raise TypeError('The rotation order is not a valid order.')
+
+        rot_order = [int(r) for r in rot_order]
+        if not (len(amounts) == 3 & len(rot_order) == 3):
+            raise TypeError('Body orientation takes 3 values & 3 orders')
+        rot_matrices = [self._rot(order, amount)
+                        for (order, amount) in zip(rot_order, amounts)]
+        return amounts, rot_order, rot_matrices
+
+    def orient_body_fixed(self, parent, angles, rotation_order):
+        """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"
+        unit vectors of a new intermediate reference frame. This type of
+        rotation is also referred to rotating through the `Euler and Tait-Bryan
+        Angles`_.
+
+        .. _Euler and Tait-Bryan Angles: https://en.wikipedia.org/wiki/Euler_angles
+
+        The computed angular velocity in this method is by default expressed in
+        the child's frame, so it is most preferable to use ``u1 * child.x + u2 *
+        child.y + u3 * child.z`` as generalized speeds.
+
+        Parameters
+        ==========
+
+        parent : ReferenceFrame
+            Reference frame that this reference frame will be rotated relative
+            to.
+        angles : 3-tuple of sympifiable
+            Three angles in radians used for the successive rotations.
+        rotation_order : 3 character string or 3 digit integer
+            Order of the rotations about each intermediate reference frames'
+            unit vectors. The Euler rotation about the X, Z', X'' axes can be
+            specified by the strings ``'XZX'``, ``'131'``, or the integer
+            ``131``. There are 12 unique valid rotation orders (6 Euler and 6
+            Tait-Bryan): zxz, xyx, yzy, zyz, xzx, yxy, xyz, yzx, zxy, xzy, zyx,
+            and yxz.
+
+        Warns
+        ======
+
+        UserWarning
+            If the orientation creates a kinematic loop.
+
+        Examples
+        ========
+
+        Setup variables for the examples:
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> q1, q2, q3 = symbols('q1, q2, q3')
+        >>> N = ReferenceFrame('N')
+        >>> B = ReferenceFrame('B')
+        >>> B1 = ReferenceFrame('B1')
+        >>> B2 = ReferenceFrame('B2')
+        >>> B3 = ReferenceFrame('B3')
+
+        For example, a classic Euler Angle rotation can be done by:
+
+        >>> B.orient_body_fixed(N, (q1, q2, q3), 'XYX')
+        >>> B.dcm(N)
+        Matrix([
+        [        cos(q2),                            sin(q1)*sin(q2),                           -sin(q2)*cos(q1)],
+        [sin(q2)*sin(q3), -sin(q1)*sin(q3)*cos(q2) + cos(q1)*cos(q3),  sin(q1)*cos(q3) + sin(q3)*cos(q1)*cos(q2)],
+        [sin(q2)*cos(q3), -sin(q1)*cos(q2)*cos(q3) - sin(q3)*cos(q1), -sin(q1)*sin(q3) + cos(q1)*cos(q2)*cos(q3)]])
+
+        This rotates reference frame B relative to reference frame N through
+        ``q1`` about ``N.x``, then rotates B again through ``q2`` about
+        ``B.y``, and finally through ``q3`` about ``B.x``. It is equivalent to
+        three successive ``orient_axis()`` calls:
+
+        >>> B1.orient_axis(N, N.x, q1)
+        >>> B2.orient_axis(B1, B1.y, q2)
+        >>> B3.orient_axis(B2, B2.x, q3)
+        >>> B3.dcm(N)
+        Matrix([
+        [        cos(q2),                            sin(q1)*sin(q2),                           -sin(q2)*cos(q1)],
+        [sin(q2)*sin(q3), -sin(q1)*sin(q3)*cos(q2) + cos(q1)*cos(q3),  sin(q1)*cos(q3) + sin(q3)*cos(q1)*cos(q2)],
+        [sin(q2)*cos(q3), -sin(q1)*cos(q2)*cos(q3) - sin(q3)*cos(q1), -sin(q1)*sin(q3) + cos(q1)*cos(q2)*cos(q3)]])
+
+        Acceptable rotation orders are of length 3, expressed in as a string
+        ``'XYZ'`` or ``'123'`` or integer ``123``. Rotations about an axis
+        twice in a row are prohibited.
+
+        >>> B.orient_body_fixed(N, (q1, q2, 0), 'ZXZ')
+        >>> B.orient_body_fixed(N, (q1, q2, 0), '121')
+        >>> B.orient_body_fixed(N, (q1, q2, q3), 123)
+
+        """
+        from sympy.physics.vector.functions import dynamicsymbols
+
+        _check_frame(parent)
+
+        amounts, rot_order, rot_matrices = self._parse_consecutive_rotations(
+            angles, rotation_order)
+        self._dcm(parent, rot_matrices[0] * rot_matrices[1] * rot_matrices[2])
+
+        rot_vecs = [zeros(3, 1) for _ in range(3)]
+        for i, order in enumerate(rot_order):
+            rot_vecs[i][order - 1] = amounts[i].diff(dynamicsymbols._t)
+        u1, u2, u3 = rot_vecs[2] + rot_matrices[2].T * (
+            rot_vecs[1] + rot_matrices[1].T * rot_vecs[0])
+        wvec = u1 * self.x + u2 * self.y + u3 * self.z  # There is a double -
+        self._ang_vel_dict.update({parent: wvec})
+        parent._ang_vel_dict.update({self: -wvec})
+        self._var_dict = {}
+
+    def orient_space_fixed(self, parent, angles, rotation_order):
+        """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"
+        unit vectors of the parent reference frame.
+
+        The computed angular velocity in this method is by default expressed in
+        the child's frame, so it is most preferable to use ``u1 * child.x + u2 *
+        child.y + u3 * child.z`` as generalized speeds.
+
+        Parameters
+        ==========
+        parent : ReferenceFrame
+            Reference frame that this reference frame will be rotated relative
+            to.
+        angles : 3-tuple of sympifiable
+            Three angles in radians used for the successive rotations.
+        rotation_order : 3 character string or 3 digit integer
+            Order of the rotations about the parent reference frame's unit
+            vectors. The order can be specified by the strings ``'XZX'``,
+            ``'131'``, or the integer ``131``. There are 12 unique valid
+            rotation orders.
+
+        Warns
+        ======
+
+        UserWarning
+            If the orientation creates a kinematic loop.
+
+        Examples
+        ========
+
+        Setup variables for the examples:
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> q1, q2, q3 = symbols('q1, q2, q3')
+        >>> N = ReferenceFrame('N')
+        >>> B = ReferenceFrame('B')
+        >>> B1 = ReferenceFrame('B1')
+        >>> B2 = ReferenceFrame('B2')
+        >>> B3 = ReferenceFrame('B3')
+
+        >>> B.orient_space_fixed(N, (q1, q2, q3), '312')
+        >>> B.dcm(N)
+        Matrix([
+        [ sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3), sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1)],
+        [-sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1), cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3)],
+        [                           sin(q3)*cos(q2),        -sin(q2),                           cos(q2)*cos(q3)]])
+
+        is equivalent to:
+
+        >>> B1.orient_axis(N, N.z, q1)
+        >>> B2.orient_axis(B1, N.x, q2)
+        >>> B3.orient_axis(B2, N.y, q3)
+        >>> B3.dcm(N).simplify()
+        Matrix([
+        [ sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3), sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1)],
+        [-sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1), cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3)],
+        [                           sin(q3)*cos(q2),        -sin(q2),                           cos(q2)*cos(q3)]])
+
+        It is worth noting that space-fixed and body-fixed rotations are
+        related by the order of the rotations, i.e. the reverse order of body
+        fixed will give space fixed and vice versa.
+
+        >>> B.orient_space_fixed(N, (q1, q2, q3), '231')
+        >>> B.dcm(N)
+        Matrix([
+        [cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3), -sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)],
+        [       -sin(q2),                           cos(q2)*cos(q3),                            sin(q3)*cos(q2)],
+        [sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1),  sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3)]])
+
+        >>> B.orient_body_fixed(N, (q3, q2, q1), '132')
+        >>> B.dcm(N)
+        Matrix([
+        [cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3), -sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)],
+        [       -sin(q2),                           cos(q2)*cos(q3),                            sin(q3)*cos(q2)],
+        [sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1),  sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3)]])
+
+        """
+        from sympy.physics.vector.functions import dynamicsymbols
+
+        _check_frame(parent)
+
+        amounts, rot_order, rot_matrices = self._parse_consecutive_rotations(
+            angles, rotation_order)
+        self._dcm(parent, rot_matrices[2] * rot_matrices[1] * rot_matrices[0])
+
+        rot_vecs = [zeros(3, 1) for _ in range(3)]
+        for i, order in enumerate(rot_order):
+            rot_vecs[i][order - 1] = amounts[i].diff(dynamicsymbols._t)
+        u1, u2, u3 = rot_vecs[0] + rot_matrices[0].T * (
+            rot_vecs[1] + rot_matrices[1].T * rot_vecs[2])
+        wvec = u1 * self.x + u2 * self.y + u3 * self.z  # There is a double -
+        self._ang_vel_dict.update({parent: wvec})
+        parent._ang_vel_dict.update({self: -wvec})
+        self._var_dict = {}
+
+    def orient_quaternion(self, parent, numbers):
+        """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,
+        lambda_y, lambda_z)``, by an angle ``theta``. The orientation
+        quaternion is described by four parameters:
+
+        - ``q0 = cos(theta/2)``
+        - ``q1 = lambda_x*sin(theta/2)``
+        - ``q2 = lambda_y*sin(theta/2)``
+        - ``q3 = lambda_z*sin(theta/2)``
+
+        See `Quaternions and Spatial Rotation
+        <https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation>`_ on
+        Wikipedia for more information.
+
+        Parameters
+        ==========
+        parent : ReferenceFrame
+            Reference frame that this reference frame will be rotated relative
+            to.
+        numbers : 4-tuple of sympifiable
+            The four quaternion scalar numbers as defined above: ``q0``,
+            ``q1``, ``q2``, ``q3``.
+
+        Warns
+        ======
+
+        UserWarning
+            If the orientation creates a kinematic loop.
+
+        Examples
+        ========
+
+        Setup variables for the examples:
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> q0, q1, q2, q3 = symbols('q0 q1 q2 q3')
+        >>> N = ReferenceFrame('N')
+        >>> B = ReferenceFrame('B')
+
+        Set the orientation:
+
+        >>> B.orient_quaternion(N, (q0, q1, q2, q3))
+        >>> B.dcm(N)
+        Matrix([
+        [q0**2 + q1**2 - q2**2 - q3**2,             2*q0*q3 + 2*q1*q2,            -2*q0*q2 + 2*q1*q3],
+        [           -2*q0*q3 + 2*q1*q2, q0**2 - q1**2 + q2**2 - q3**2,             2*q0*q1 + 2*q2*q3],
+        [            2*q0*q2 + 2*q1*q3,            -2*q0*q1 + 2*q2*q3, q0**2 - q1**2 - q2**2 + q3**2]])
+
+        """
+
+        from sympy.physics.vector.functions import dynamicsymbols
+        _check_frame(parent)
+
+        numbers = list(numbers)
+        for i, v in enumerate(numbers):
+            if not isinstance(v, Vector):
+                numbers[i] = sympify(v)
+
+        if not (isinstance(numbers, (list, tuple)) & (len(numbers) == 4)):
+            raise TypeError('Amounts are a list or tuple of length 4')
+        q0, q1, q2, q3 = numbers
+        parent_orient_quaternion = (
+            Matrix([[q0**2 + q1**2 - q2**2 - q3**2,
+                     2 * (q1 * q2 - q0 * q3),
+                     2 * (q0 * q2 + q1 * q3)],
+                    [2 * (q1 * q2 + q0 * q3),
+                     q0**2 - q1**2 + q2**2 - q3**2,
+                     2 * (q2 * q3 - q0 * q1)],
+                    [2 * (q1 * q3 - q0 * q2),
+                     2 * (q0 * q1 + q2 * q3),
+                     q0**2 - q1**2 - q2**2 + q3**2]]))
+
+        self._dcm(parent, parent_orient_quaternion)
+
+        t = dynamicsymbols._t
+        q0, q1, q2, q3 = numbers
+        q0d = diff(q0, t)
+        q1d = diff(q1, t)
+        q2d = diff(q2, t)
+        q3d = diff(q3, t)
+        w1 = 2 * (q1d * q0 + q2d * q3 - q3d * q2 - q0d * q1)
+        w2 = 2 * (q2d * q0 + q3d * q1 - q1d * q3 - q0d * q2)
+        w3 = 2 * (q3d * q0 + q1d * q2 - q2d * q1 - q0d * q3)
+        wvec = Vector([(Matrix([w1, w2, w3]), self)])
+
+        self._ang_vel_dict.update({parent: wvec})
+        parent._ang_vel_dict.update({self: -wvec})
+        self._var_dict = {}
+
+    def orient(self, parent, rot_type, amounts, rot_order=''):
+        """Sets the orientation of this reference frame relative to another
+        (parent) reference frame.
+
+        .. note:: It is now recommended to use the ``.orient_axis,
+           .orient_body_fixed, .orient_space_fixed, .orient_quaternion``
+           methods for the different rotation types.
+
+        Parameters
+        ==========
+
+        parent : ReferenceFrame
+            Reference frame that this reference frame will be rotated relative
+            to.
+        rot_type : str
+            The method used to generate the direction cosine matrix. Supported
+            methods are:
+
+            - ``'Axis'``: simple rotations about a single common axis
+            - ``'DCM'``: for setting the direction cosine matrix directly
+            - ``'Body'``: three successive rotations about new intermediate
+              axes, also called "Euler and Tait-Bryan angles"
+            - ``'Space'``: three successive rotations about the parent
+              frames' unit vectors
+            - ``'Quaternion'``: rotations defined by four parameters which
+              result in a singularity free direction cosine matrix
+
+        amounts :
+            Expressions defining the rotation angles or direction cosine
+            matrix. These must match the ``rot_type``. See examples below for
+            details. The input types are:
+
+            - ``'Axis'``: 2-tuple (expr/sym/func, Vector)
+            - ``'DCM'``: Matrix, shape(3,3)
+            - ``'Body'``: 3-tuple of expressions, symbols, or functions
+            - ``'Space'``: 3-tuple of expressions, symbols, or functions
+            - ``'Quaternion'``: 4-tuple of expressions, symbols, or
+              functions
+
+        rot_order : str or int, optional
+            If applicable, the order of the successive of rotations. The string
+            ``'123'`` and integer ``123`` are equivalent, for example. Required
+            for ``'Body'`` and ``'Space'``.
+
+        Warns
+        ======
+
+        UserWarning
+            If the orientation creates a kinematic loop.
+
+        """
+
+        _check_frame(parent)
+
+        approved_orders = ('123', '231', '312', '132', '213', '321', '121',
+                           '131', '212', '232', '313', '323', '')
+        rot_order = translate(str(rot_order), 'XYZxyz', '123123')
+        rot_type = rot_type.upper()
+
+        if rot_order not in approved_orders:
+            raise TypeError('The supplied order is not an approved type')
+
+        if rot_type == 'AXIS':
+            self.orient_axis(parent, amounts[1], amounts[0])
+
+        elif rot_type == 'DCM':
+            self.orient_explicit(parent, amounts)
+
+        elif rot_type == 'BODY':
+            self.orient_body_fixed(parent, amounts, rot_order)
+
+        elif rot_type == 'SPACE':
+            self.orient_space_fixed(parent, amounts, rot_order)
+
+        elif rot_type == 'QUATERNION':
+            self.orient_quaternion(parent, amounts)
+
+        else:
+            raise NotImplementedError('That is not an implemented rotation')
+
+    def orientnew(self, newname, rot_type, amounts, rot_order='',
+                  variables=None, indices=None, latexs=None):
+        r"""Returns a new reference frame oriented with respect to this
+        reference frame.
+
+        See ``ReferenceFrame.orient()`` for detailed examples of how to orient
+        reference frames.
+
+        Parameters
+        ==========
+
+        newname : str
+            Name for the new reference frame.
+        rot_type : str
+            The method used to generate the direction cosine matrix. Supported
+            methods are:
+
+            - ``'Axis'``: simple rotations about a single common axis
+            - ``'DCM'``: for setting the direction cosine matrix directly
+            - ``'Body'``: three successive rotations about new intermediate
+              axes, also called "Euler and Tait-Bryan angles"
+            - ``'Space'``: three successive rotations about the parent
+              frames' unit vectors
+            - ``'Quaternion'``: rotations defined by four parameters which
+              result in a singularity free direction cosine matrix
+
+        amounts :
+            Expressions defining the rotation angles or direction cosine
+            matrix. These must match the ``rot_type``. See examples below for
+            details. The input types are:
+
+            - ``'Axis'``: 2-tuple (expr/sym/func, Vector)
+            - ``'DCM'``: Matrix, shape(3,3)
+            - ``'Body'``: 3-tuple of expressions, symbols, or functions
+            - ``'Space'``: 3-tuple of expressions, symbols, or functions
+            - ``'Quaternion'``: 4-tuple of expressions, symbols, or
+              functions
+
+        rot_order : str or int, optional
+            If applicable, the order of the successive of rotations. The string
+            ``'123'`` and integer ``123`` are equivalent, for example. Required
+            for ``'Body'`` and ``'Space'``.
+        indices : tuple of str
+            Enables the reference frame's basis unit vectors to be accessed by
+            Python's square bracket indexing notation using the provided three
+            indice strings and alters the printing of the unit vectors to
+            reflect this choice.
+        latexs : tuple of str
+            Alters the LaTeX printing of the reference frame's basis unit
+            vectors to the provided three valid LaTeX strings.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.vector import ReferenceFrame, vlatex
+        >>> q0, q1, q2, q3 = symbols('q0 q1 q2 q3')
+        >>> N = ReferenceFrame('N')
+
+        Create a new reference frame A rotated relative to N through a simple
+        rotation.
+
+        >>> A = N.orientnew('A', 'Axis', (q0, N.x))
+
+        Create a new reference frame B rotated relative to N through body-fixed
+        rotations.
+
+        >>> B = N.orientnew('B', 'Body', (q1, q2, q3), '123')
+
+        Create a new reference frame C rotated relative to N through a simple
+        rotation with unique indices and LaTeX printing.
+
+        >>> C = N.orientnew('C', 'Axis', (q0, N.x), indices=('1', '2', '3'),
+        ... latexs=(r'\hat{\mathbf{c}}_1',r'\hat{\mathbf{c}}_2',
+        ... r'\hat{\mathbf{c}}_3'))
+        >>> C['1']
+        C['1']
+        >>> print(vlatex(C['1']))
+        \hat{\mathbf{c}}_1
+
+        """
+
+        newframe = self.__class__(newname, variables=variables,
+                                  indices=indices, latexs=latexs)
+
+        approved_orders = ('123', '231', '312', '132', '213', '321', '121',
+                           '131', '212', '232', '313', '323', '')
+        rot_order = translate(str(rot_order), 'XYZxyz', '123123')
+        rot_type = rot_type.upper()
+
+        if rot_order not in approved_orders:
+            raise TypeError('The supplied order is not an approved type')
+
+        if rot_type == 'AXIS':
+            newframe.orient_axis(self, amounts[1], amounts[0])
+
+        elif rot_type == 'DCM':
+            newframe.orient_explicit(self, amounts)
+
+        elif rot_type == 'BODY':
+            newframe.orient_body_fixed(self, amounts, rot_order)
+
+        elif rot_type == 'SPACE':
+            newframe.orient_space_fixed(self, amounts, rot_order)
+
+        elif rot_type == 'QUATERNION':
+            newframe.orient_quaternion(self, amounts)
+
+        else:
+            raise NotImplementedError('That is not an implemented rotation')
+        return newframe
+
+    def set_ang_acc(self, otherframe, value):
+        """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
+        ReferenceFrames. Care must be taken to not create loops which are
+        inconsistent.
+
+        Parameters
+        ==========
+
+        otherframe : ReferenceFrame
+            A ReferenceFrame to define the angular acceleration in
+        value : Vector
+            The Vector representing angular acceleration
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> A = ReferenceFrame('A')
+        >>> V = 10 * N.x
+        >>> A.set_ang_acc(N, V)
+        >>> A.ang_acc_in(N)
+        10*N.x
+
+        """
+
+        if value == 0:
+            value = Vector(0)
+        value = _check_vector(value)
+        _check_frame(otherframe)
+        self._ang_acc_dict.update({otherframe: value})
+        otherframe._ang_acc_dict.update({self: -value})
+
+    def set_ang_vel(self, otherframe, value):
+        """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
+        ReferenceFrames. Care must be taken to not create loops which are
+        inconsistent.
+
+        Parameters
+        ==========
+
+        otherframe : ReferenceFrame
+            A ReferenceFrame to define the angular velocity in
+        value : Vector
+            The Vector representing angular velocity
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> A = ReferenceFrame('A')
+        >>> V = 10 * N.x
+        >>> A.set_ang_vel(N, V)
+        >>> A.ang_vel_in(N)
+        10*N.x
+
+        """
+
+        if value == 0:
+            value = Vector(0)
+        value = _check_vector(value)
+        _check_frame(otherframe)
+        self._ang_vel_dict.update({otherframe: value})
+        otherframe._ang_vel_dict.update({self: -value})
+
+    @property
+    def x(self):
+        """The basis Vector for the ReferenceFrame, in the x direction. """
+        return self._x
+
+    @property
+    def y(self):
+        """The basis Vector for the ReferenceFrame, in the y direction. """
+        return self._y
+
+    @property
+    def z(self):
+        """The basis Vector for the ReferenceFrame, in the z direction. """
+        return self._z
+
+    @property
+    def xx(self):
+        """Unit dyad of basis Vectors x and x for the ReferenceFrame."""
+        return Vector.outer(self.x, self.x)
+
+    @property
+    def xy(self):
+        """Unit dyad of basis Vectors x and y for the ReferenceFrame."""
+        return Vector.outer(self.x, self.y)
+
+    @property
+    def xz(self):
+        """Unit dyad of basis Vectors x and z for the ReferenceFrame."""
+        return Vector.outer(self.x, self.z)
+
+    @property
+    def yx(self):
+        """Unit dyad of basis Vectors y and x for the ReferenceFrame."""
+        return Vector.outer(self.y, self.x)
+
+    @property
+    def yy(self):
+        """Unit dyad of basis Vectors y and y for the ReferenceFrame."""
+        return Vector.outer(self.y, self.y)
+
+    @property
+    def yz(self):
+        """Unit dyad of basis Vectors y and z for the ReferenceFrame."""
+        return Vector.outer(self.y, self.z)
+
+    @property
+    def zx(self):
+        """Unit dyad of basis Vectors z and x for the ReferenceFrame."""
+        return Vector.outer(self.z, self.x)
+
+    @property
+    def zy(self):
+        """Unit dyad of basis Vectors z and y for the ReferenceFrame."""
+        return Vector.outer(self.z, self.y)
+
+    @property
+    def zz(self):
+        """Unit dyad of basis Vectors z and z for the ReferenceFrame."""
+        return Vector.outer(self.z, self.z)
+
+    @property
+    def u(self):
+        """Unit dyadic for the ReferenceFrame."""
+        return self.xx + self.yy + self.zz
+
+    def partial_velocity(self, frame, *gen_speeds):
+        """Returns the partial angular velocities of this frame in the given
+        frame with respect to one or more provided generalized speeds.
+
+        Parameters
+        ==========
+        frame : ReferenceFrame
+            The frame with which the angular velocity is defined in.
+        gen_speeds : functions of time
+            The generalized speeds.
+
+        Returns
+        =======
+        partial_velocities : tuple of Vector
+            The partial angular velocity vectors corresponding to the provided
+            generalized speeds.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, dynamicsymbols
+        >>> N = ReferenceFrame('N')
+        >>> A = ReferenceFrame('A')
+        >>> u1, u2 = dynamicsymbols('u1, u2')
+        >>> A.set_ang_vel(N, u1 * A.x + u2 * N.y)
+        >>> A.partial_velocity(N, u1)
+        A.x
+        >>> A.partial_velocity(N, u1, u2)
+        (A.x, N.y)
+
+        """
+
+        from sympy.physics.vector.functions import partial_velocity
+
+        vel = self.ang_vel_in(frame)
+        partials = partial_velocity([vel], gen_speeds, frame)[0]
+
+        if len(partials) == 1:
+            return partials[0]
+        else:
+            return tuple(partials)
+
+
+def _check_frame(other):
+    from .vector import VectorTypeError
+    if not isinstance(other, ReferenceFrame):
+        raise VectorTypeError(other, ReferenceFrame('A'))

venv/lib/python3.11/site-packages/sympy/physics/vector/functions.py

@@ -0,0 +1,650 @@
+from functools import reduce
+
+from sympy import (sympify, diff, sin, cos, Matrix, symbols,
+                                Function, S, Symbol, linear_eq_to_matrix)
+from sympy.integrals.integrals import integrate
+from sympy.simplify.trigsimp import trigsimp
+from .vector import Vector, _check_vector
+from .frame import CoordinateSym, _check_frame
+from .dyadic import Dyadic
+from .printing import vprint, vsprint, vpprint, vlatex, init_vprinting
+from sympy.utilities.iterables import iterable
+from sympy.utilities.misc import translate
+
+__all__ = ['cross', 'dot', 'express', 'time_derivative', 'outer',
+           'kinematic_equations', 'get_motion_params', 'partial_velocity',
+           'dynamicsymbols', 'vprint', 'vsprint', 'vpprint', 'vlatex',
+           'init_vprinting']
+
+
+def cross(vec1, vec2):
+    """Cross product convenience wrapper for Vector.cross(): \n"""
+    if not isinstance(vec1, (Vector, Dyadic)):
+        raise TypeError('Cross product is between two vectors')
+    return vec1 ^ vec2
+
+
+cross.__doc__ += Vector.cross.__doc__  # type: ignore
+
+
+def dot(vec1, vec2):
+    """Dot product convenience wrapper for Vector.dot(): \n"""
+    if not isinstance(vec1, (Vector, Dyadic)):
+        raise TypeError('Dot product is between two vectors')
+    return vec1 & vec2
+
+
+dot.__doc__ += Vector.dot.__doc__  # type: ignore
+
+
+def express(expr, frame, frame2=None, variables=False):
+    """
+    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.
+    If 'variables' is True, then the coordinate variables (CoordinateSym
+    instances) of other frames present in the vector/scalar field or
+    dyadic expression are also substituted in terms of the base scalars of
+    this frame.
+
+    Parameters
+    ==========
+
+    expr : Vector/Dyadic/scalar(sympyfiable)
+        The expression to re-express in ReferenceFrame 'frame'
+
+    frame: ReferenceFrame
+        The reference frame to express expr in
+
+    frame2 : ReferenceFrame
+        The other frame required for re-expression(only for Dyadic expr)
+
+    variables : boolean
+        Specifies whether to substitute the coordinate variables present
+        in expr, in terms of those of frame
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame, outer, dynamicsymbols
+    >>> from sympy.physics.vector import init_vprinting
+    >>> init_vprinting(pretty_print=False)
+    >>> N = ReferenceFrame('N')
+    >>> q = dynamicsymbols('q')
+    >>> B = N.orientnew('B', 'Axis', [q, N.z])
+    >>> d = outer(N.x, N.x)
+    >>> from sympy.physics.vector import express
+    >>> express(d, B, N)
+    cos(q)*(B.x|N.x) - sin(q)*(B.y|N.x)
+    >>> express(B.x, N)
+    cos(q)*N.x + sin(q)*N.y
+    >>> express(N[0], B, variables=True)
+    B_x*cos(q) - B_y*sin(q)
+
+    """
+
+    _check_frame(frame)
+
+    if expr == 0:
+        return expr
+
+    if isinstance(expr, Vector):
+        # Given expr is a Vector
+        if variables:
+            # If variables attribute is True, substitute the coordinate
+            # variables in the Vector
+            frame_list = [x[-1] for x in expr.args]
+            subs_dict = {}
+            for f in frame_list:
+                subs_dict.update(f.variable_map(frame))
+            expr = expr.subs(subs_dict)
+        # Re-express in this frame
+        outvec = Vector([])
+        for v in expr.args:
+            if v[1] != frame:
+                temp = frame.dcm(v[1]) * v[0]
+                if Vector.simp:
+                    temp = temp.applyfunc(lambda x:
+                                          trigsimp(x, method='fu'))
+                outvec += Vector([(temp, frame)])
+            else:
+                outvec += Vector([v])
+        return outvec
+
+    if isinstance(expr, Dyadic):
+        if frame2 is None:
+            frame2 = frame
+        _check_frame(frame2)
+        ol = Dyadic(0)
+        for v in expr.args:
+            ol += express(v[0], frame, variables=variables) * \
+                  (express(v[1], frame, variables=variables) |
+                   express(v[2], frame2, variables=variables))
+        return ol
+
+    else:
+        if variables:
+            # Given expr is a scalar field
+            frame_set = set()
+            expr = sympify(expr)
+            # Substitute all the coordinate variables
+            for x in expr.free_symbols:
+                if isinstance(x, CoordinateSym) and x.frame != frame:
+                    frame_set.add(x.frame)
+            subs_dict = {}
+            for f in frame_set:
+                subs_dict.update(f.variable_map(frame))
+            return expr.subs(subs_dict)
+        return expr
+
+
+def time_derivative(expr, frame, order=1):
+    """
+    Calculate the time derivative of a vector/scalar field function
+    or dyadic expression in given frame.
+
+    References
+    ==========
+
+    https://en.wikipedia.org/wiki/Rotating_reference_frame#Time_derivatives_in_the_two_frames
+
+    Parameters
+    ==========
+
+    expr : Vector/Dyadic/sympifyable
+        The expression whose time derivative is to be calculated
+
+    frame : ReferenceFrame
+        The reference frame to calculate the time derivative in
+
+    order : integer
+        The order of the derivative to be calculated
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame, dynamicsymbols
+    >>> from sympy.physics.vector import init_vprinting
+    >>> init_vprinting(pretty_print=False)
+    >>> from sympy import Symbol
+    >>> q1 = Symbol('q1')
+    >>> u1 = dynamicsymbols('u1')
+    >>> N = ReferenceFrame('N')
+    >>> A = N.orientnew('A', 'Axis', [q1, N.x])
+    >>> v = u1 * N.x
+    >>> A.set_ang_vel(N, 10*A.x)
+    >>> from sympy.physics.vector import time_derivative
+    >>> time_derivative(v, N)
+    u1'*N.x
+    >>> time_derivative(u1*A[0], N)
+    N_x*u1'
+    >>> B = N.orientnew('B', 'Axis', [u1, N.z])
+    >>> from sympy.physics.vector import outer
+    >>> d = outer(N.x, N.x)
+    >>> time_derivative(d, B)
+    - u1'*(N.y|N.x) - u1'*(N.x|N.y)
+
+    """
+
+    t = dynamicsymbols._t
+    _check_frame(frame)
+
+    if order == 0:
+        return expr
+    if order % 1 != 0 or order < 0:
+        raise ValueError("Unsupported value of order entered")
+
+    if isinstance(expr, Vector):
+        outlist = []
+        for v in expr.args:
+            if v[1] == frame:
+                outlist += [(express(v[0], frame, variables=True).diff(t),
+                             frame)]
+            else:
+                outlist += (time_derivative(Vector([v]), v[1]) +
+                            (v[1].ang_vel_in(frame) ^ Vector([v]))).args
+        outvec = Vector(outlist)
+        return time_derivative(outvec, frame, order - 1)
+
+    if isinstance(expr, Dyadic):
+        ol = Dyadic(0)
+        for v in expr.args:
+            ol += (v[0].diff(t) * (v[1] | v[2]))
+            ol += (v[0] * (time_derivative(v[1], frame) | v[2]))
+            ol += (v[0] * (v[1] | time_derivative(v[2], frame)))
+        return time_derivative(ol, frame, order - 1)
+
+    else:
+        return diff(express(expr, frame, variables=True), t, order)
+
+
+def outer(vec1, vec2):
+    """Outer product convenience wrapper for Vector.outer():\n"""
+    if not isinstance(vec1, Vector):
+        raise TypeError('Outer product is between two Vectors')
+    return vec1.outer(vec2)
+
+
+outer.__doc__ += Vector.outer.__doc__  # type: ignore
+
+
+def kinematic_equations(speeds, coords, rot_type, rot_order=''):
+    """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,
+    the angular velocity of B in A is assumed to be in the form: speed[0]*B.x +
+    speed[1]*B.y + speed[2]*B.z
+
+    Parameters
+    ==========
+
+    speeds : list of length 3
+        The body fixed angular velocity measure numbers.
+    coords : list of length 3 or 4
+        The coordinates used to define the orientation of the two frames.
+    rot_type : str
+        The type of rotation used to create the equations. Body, Space, or
+        Quaternion only
+    rot_order : str or int
+        If applicable, the order of a series of rotations.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import dynamicsymbols
+    >>> from sympy.physics.vector import kinematic_equations, vprint
+    >>> u1, u2, u3 = dynamicsymbols('u1 u2 u3')
+    >>> q1, q2, q3 = dynamicsymbols('q1 q2 q3')
+    >>> vprint(kinematic_equations([u1,u2,u3], [q1,q2,q3], 'body', '313'),
+    ...     order=None)
+    [-(u1*sin(q3) + u2*cos(q3))/sin(q2) + q1', -u1*cos(q3) + u2*sin(q3) + q2', (u1*sin(q3) + u2*cos(q3))*cos(q2)/sin(q2) - u3 + q3']
+
+    """
+
+    # Code below is checking and sanitizing input
+    approved_orders = ('123', '231', '312', '132', '213', '321', '121', '131',
+                       '212', '232', '313', '323', '1', '2', '3', '')
+    # make sure XYZ => 123 and rot_type is in lower case
+    rot_order = translate(str(rot_order), 'XYZxyz', '123123')
+    rot_type = rot_type.lower()
+
+    if not isinstance(speeds, (list, tuple)):
+        raise TypeError('Need to supply speeds in a list')
+    if len(speeds) != 3:
+        raise TypeError('Need to supply 3 body-fixed speeds')
+    if not isinstance(coords, (list, tuple)):
+        raise TypeError('Need to supply coordinates in a list')
+    if rot_type in ['body', 'space']:
+        if rot_order not in approved_orders:
+            raise ValueError('Not an acceptable rotation order')
+        if len(coords) != 3:
+            raise ValueError('Need 3 coordinates for body or space')
+        # Actual hard-coded kinematic differential equations
+        w1, w2, w3 = speeds
+        if w1 == w2 == w3 == 0:
+            return [S.Zero]*3
+        q1, q2, q3 = coords
+        q1d, q2d, q3d = [diff(i, dynamicsymbols._t) for i in coords]
+        s1, s2, s3 = [sin(q1), sin(q2), sin(q3)]
+        c1, c2, c3 = [cos(q1), cos(q2), cos(q3)]
+        if rot_type == 'body':
+            if rot_order == '123':
+                return [q1d - (w1 * c3 - w2 * s3) / c2, q2d - w1 * s3 - w2 *
+                        c3, q3d - (-w1 * c3 + w2 * s3) * s2 / c2 - w3]
+            if rot_order == '231':
+                return [q1d - (w2 * c3 - w3 * s3) / c2, q2d - w2 * s3 - w3 *
+                        c3, q3d - w1 - (- w2 * c3 + w3 * s3) * s2 / c2]
+            if rot_order == '312':
+                return [q1d - (-w1 * s3 + w3 * c3) / c2, q2d - w1 * c3 - w3 *
+                        s3, q3d - (w1 * s3 - w3 * c3) * s2 / c2 - w2]
+            if rot_order == '132':
+                return [q1d - (w1 * c3 + w3 * s3) / c2, q2d + w1 * s3 - w3 *
+                        c3, q3d - (w1 * c3 + w3 * s3) * s2 / c2 - w2]
+            if rot_order == '213':
+                return [q1d - (w1 * s3 + w2 * c3) / c2, q2d - w1 * c3 + w2 *
+                        s3, q3d - (w1 * s3 + w2 * c3) * s2 / c2 - w3]
+            if rot_order == '321':
+                return [q1d - (w2 * s3 + w3 * c3) / c2, q2d - w2 * c3 + w3 *
+                        s3, q3d - w1 - (w2 * s3 + w3 * c3) * s2 / c2]
+            if rot_order == '121':
+                return [q1d - (w2 * s3 + w3 * c3) / s2, q2d - w2 * c3 + w3 *
+                        s3, q3d - w1 + (w2 * s3 + w3 * c3) * c2 / s2]
+            if rot_order == '131':
+                return [q1d - (-w2 * c3 + w3 * s3) / s2, q2d - w2 * s3 - w3 *
+                        c3, q3d - w1 - (w2 * c3 - w3 * s3) * c2 / s2]
+            if rot_order == '212':
+                return [q1d - (w1 * s3 - w3 * c3) / s2, q2d - w1 * c3 - w3 *
+                        s3, q3d - (-w1 * s3 + w3 * c3) * c2 / s2 - w2]
+            if rot_order == '232':
+                return [q1d - (w1 * c3 + w3 * s3) / s2, q2d + w1 * s3 - w3 *
+                        c3, q3d + (w1 * c3 + w3 * s3) * c2 / s2 - w2]
+            if rot_order == '313':
+                return [q1d - (w1 * s3 + w2 * c3) / s2, q2d - w1 * c3 + w2 *
+                        s3, q3d + (w1 * s3 + w2 * c3) * c2 / s2 - w3]
+            if rot_order == '323':
+                return [q1d - (-w1 * c3 + w2 * s3) / s2, q2d - w1 * s3 - w2 *
+                        c3, q3d - (w1 * c3 - w2 * s3) * c2 / s2 - w3]
+        if rot_type == 'space':
+            if rot_order == '123':
+                return [q1d - w1 - (w2 * s1 + w3 * c1) * s2 / c2, q2d - w2 *
+                        c1 + w3 * s1, q3d - (w2 * s1 + w3 * c1) / c2]
+            if rot_order == '231':
+                return [q1d - (w1 * c1 + w3 * s1) * s2 / c2 - w2, q2d + w1 *
+                        s1 - w3 * c1, q3d - (w1 * c1 + w3 * s1) / c2]
+            if rot_order == '312':
+                return [q1d - (w1 * s1 + w2 * c1) * s2 / c2 - w3, q2d - w1 *
+                        c1 + w2 * s1, q3d - (w1 * s1 + w2 * c1) / c2]
+            if rot_order == '132':
+                return [q1d - w1 - (-w2 * c1 + w3 * s1) * s2 / c2, q2d - w2 *
+                        s1 - w3 * c1, q3d - (w2 * c1 - w3 * s1) / c2]
+            if rot_order == '213':
+                return [q1d - (w1 * s1 - w3 * c1) * s2 / c2 - w2, q2d - w1 *
+                        c1 - w3 * s1, q3d - (-w1 * s1 + w3 * c1) / c2]
+            if rot_order == '321':
+                return [q1d - (-w1 * c1 + w2 * s1) * s2 / c2 - w3, q2d - w1 *
+                        s1 - w2 * c1, q3d - (w1 * c1 - w2 * s1) / c2]
+            if rot_order == '121':
+                return [q1d - w1 + (w2 * s1 + w3 * c1) * c2 / s2, q2d - w2 *
+                        c1 + w3 * s1, q3d - (w2 * s1 + w3 * c1) / s2]
+            if rot_order == '131':
+                return [q1d - w1 - (w2 * c1 - w3 * s1) * c2 / s2, q2d - w2 *
+                        s1 - w3 * c1, q3d - (-w2 * c1 + w3 * s1) / s2]
+            if rot_order == '212':
+                return [q1d - (-w1 * s1 + w3 * c1) * c2 / s2 - w2, q2d - w1 *
+                        c1 - w3 * s1, q3d - (w1 * s1 - w3 * c1) / s2]
+            if rot_order == '232':
+                return [q1d + (w1 * c1 + w3 * s1) * c2 / s2 - w2, q2d + w1 *
+                        s1 - w3 * c1, q3d - (w1 * c1 + w3 * s1) / s2]
+            if rot_order == '313':
+                return [q1d + (w1 * s1 + w2 * c1) * c2 / s2 - w3, q2d - w1 *
+                        c1 + w2 * s1, q3d - (w1 * s1 + w2 * c1) / s2]
+            if rot_order == '323':
+                return [q1d - (w1 * c1 - w2 * s1) * c2 / s2 - w3, q2d - w1 *
+                        s1 - w2 * c1, q3d - (-w1 * c1 + w2 * s1) / s2]
+    elif rot_type == 'quaternion':
+        if rot_order != '':
+            raise ValueError('Cannot have rotation order for quaternion')
+        if len(coords) != 4:
+            raise ValueError('Need 4 coordinates for quaternion')
+        # Actual hard-coded kinematic differential equations
+        e0, e1, e2, e3 = coords
+        w = Matrix(speeds + [0])
+        E = Matrix([[e0, -e3, e2, e1],
+                    [e3, e0, -e1, e2],
+                    [-e2, e1, e0, e3],
+                    [-e1, -e2, -e3, e0]])
+        edots = Matrix([diff(i, dynamicsymbols._t) for i in [e1, e2, e3, e0]])
+        return list(edots.T - 0.5 * w.T * E.T)
+    else:
+        raise ValueError('Not an approved rotation type for this function')
+
+
+def get_motion_params(frame, **kwargs):
+    """
+    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
+    functions are used as boundary conditions. For example, given the
+    acceleration, the velocity and position parameters are taken as
+    boundary conditions.
+
+    The values of time at which the boundary conditions are specified
+    are taken from timevalue1(for position boundary condition) and
+    timevalue2(for velocity boundary condition).
+
+    If any of the boundary conditions are not provided, they are taken
+    to be zero by default (zero vectors, in case of vectorial inputs). If
+    the boundary conditions are also functions of time, they are converted
+    to constants by substituting the time values in the dynamicsymbols._t
+    time Symbol.
+
+    This function can also be used for calculating rotational motion
+    parameters. Have a look at the Parameters and Examples for more clarity.
+
+    Parameters
+    ==========
+
+    frame : ReferenceFrame
+        The frame to express the motion parameters in
+
+    acceleration : Vector
+        Acceleration of the object/frame as a function of time
+
+    velocity : Vector
+        Velocity as function of time or as boundary condition
+        of velocity at time = timevalue1
+
+    position : Vector
+        Velocity as function of time or as boundary condition
+        of velocity at time = timevalue1
+
+    timevalue1 : sympyfiable
+        Value of time for position boundary condition
+
+    timevalue2 : sympyfiable
+        Value of time for velocity boundary condition
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame, get_motion_params, dynamicsymbols
+    >>> from sympy.physics.vector import init_vprinting
+    >>> init_vprinting(pretty_print=False)
+    >>> from sympy import symbols
+    >>> R = ReferenceFrame('R')
+    >>> v1, v2, v3 = dynamicsymbols('v1 v2 v3')
+    >>> v = v1*R.x + v2*R.y + v3*R.z
+    >>> get_motion_params(R, position = v)
+    (v1''*R.x + v2''*R.y + v3''*R.z, v1'*R.x + v2'*R.y + v3'*R.z, v1*R.x + v2*R.y + v3*R.z)
+    >>> a, b, c = symbols('a b c')
+    >>> v = a*R.x + b*R.y + c*R.z
+    >>> get_motion_params(R, velocity = v)
+    (0, a*R.x + b*R.y + c*R.z, a*t*R.x + b*t*R.y + c*t*R.z)
+    >>> parameters = get_motion_params(R, acceleration = v)
+    >>> parameters[1]
+    a*t*R.x + b*t*R.y + c*t*R.z
+    >>> parameters[2]
+    a*t**2/2*R.x + b*t**2/2*R.y + c*t**2/2*R.z
+
+    """
+
+    def _process_vector_differential(vectdiff, condition, variable, ordinate,
+                                     frame):
+        """
+        Helper function for get_motion methods. Finds derivative of vectdiff
+        wrt variable, and its integral using the specified boundary condition
+        at value of variable = ordinate.
+        Returns a tuple of - (derivative, function and integral) wrt vectdiff
+
+        """
+
+        # Make sure boundary condition is independent of 'variable'
+        if condition != 0:
+            condition = express(condition, frame, variables=True)
+        # Special case of vectdiff == 0
+        if vectdiff == Vector(0):
+            return (0, 0, condition)
+        # Express vectdiff completely in condition's frame to give vectdiff1
+        vectdiff1 = express(vectdiff, frame)
+        # Find derivative of vectdiff
+        vectdiff2 = time_derivative(vectdiff, frame)
+        # Integrate and use boundary condition
+        vectdiff0 = Vector(0)
+        lims = (variable, ordinate, variable)
+        for dim in frame:
+            function1 = vectdiff1.dot(dim)
+            abscissa = dim.dot(condition).subs({variable: ordinate})
+            # Indefinite integral of 'function1' wrt 'variable', using
+            # the given initial condition (ordinate, abscissa).
+            vectdiff0 += (integrate(function1, lims) + abscissa) * dim
+        # Return tuple
+        return (vectdiff2, vectdiff, vectdiff0)
+
+    _check_frame(frame)
+    # Decide mode of operation based on user's input
+    if 'acceleration' in kwargs:
+        mode = 2
+    elif 'velocity' in kwargs:
+        mode = 1
+    else:
+        mode = 0
+    # All the possible parameters in kwargs
+    # Not all are required for every case
+    # If not specified, set to default values(may or may not be used in
+    # calculations)
+    conditions = ['acceleration', 'velocity', 'position',
+                  'timevalue', 'timevalue1', 'timevalue2']
+    for i, x in enumerate(conditions):
+        if x not in kwargs:
+            if i < 3:
+                kwargs[x] = Vector(0)
+            else:
+                kwargs[x] = S.Zero
+        elif i < 3:
+            _check_vector(kwargs[x])
+        else:
+            kwargs[x] = sympify(kwargs[x])
+    if mode == 2:
+        vel = _process_vector_differential(kwargs['acceleration'],
+                                           kwargs['velocity'],
+                                           dynamicsymbols._t,
+                                           kwargs['timevalue2'], frame)[2]
+        pos = _process_vector_differential(vel, kwargs['position'],
+                                           dynamicsymbols._t,
+                                           kwargs['timevalue1'], frame)[2]
+        return (kwargs['acceleration'], vel, pos)
+    elif mode == 1:
+        return _process_vector_differential(kwargs['velocity'],
+                                            kwargs['position'],
+                                            dynamicsymbols._t,
+                                            kwargs['timevalue1'], frame)
+    else:
+        vel = time_derivative(kwargs['position'], frame)
+        acc = time_derivative(vel, frame)
+        return (acc, vel, kwargs['position'])
+
+
+def partial_velocity(vel_vecs, gen_speeds, frame):
+    """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.
+
+    The output is a list of lists. The outer list has a number of elements
+    equal to the number of supplied velocity vectors. The inner lists are, for
+    each velocity vector, the partial derivatives of that velocity vector with
+    respect to the generalized speeds supplied.
+
+    Parameters
+    ==========
+
+    vel_vecs : iterable
+        An iterable of velocity vectors (angular or linear).
+    gen_speeds : iterable
+        An iterable of generalized speeds.
+    frame : ReferenceFrame
+        The reference frame that the partial derivatives are going to be taken
+        in.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import Point, ReferenceFrame
+    >>> from sympy.physics.vector import dynamicsymbols
+    >>> from sympy.physics.vector import partial_velocity
+    >>> u = dynamicsymbols('u')
+    >>> N = ReferenceFrame('N')
+    >>> P = Point('P')
+    >>> P.set_vel(N, u * N.x)
+    >>> vel_vecs = [P.vel(N)]
+    >>> gen_speeds = [u]
+    >>> partial_velocity(vel_vecs, gen_speeds, N)
+    [[N.x]]
+
+    """
+
+    if not iterable(vel_vecs):
+        raise TypeError('Velocity vectors must be contained in an iterable.')
+
+    if not iterable(gen_speeds):
+        raise TypeError('Generalized speeds must be contained in an iterable')
+
+    vec_partials = []
+    gen_speeds = list(gen_speeds)
+    for vel in vel_vecs:
+        partials = [Vector(0) for _ in gen_speeds]
+        for components, ref in vel.args:
+            mat, _ = linear_eq_to_matrix(components, gen_speeds)
+            for i in range(len(gen_speeds)):
+                for dim, direction in enumerate(ref):
+                    if mat[dim, i] != 0:
+                        partials[i] += direction * mat[dim, i]
+
+        vec_partials.append(partials)
+
+    return vec_partials
+
+
+def dynamicsymbols(names, level=0, **assumptions):
+    """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').
+
+    Parameters
+    ==========
+
+    names : str
+        Names of the dynamic symbols you want to create; works the same way as
+        inputs to symbols
+    level : int
+        Level of differentiation of the returned function; d/dt once of t,
+        twice of t, etc.
+    assumptions :
+        - real(bool) : This is used to set the dynamicsymbol as real,
+                    by default is False.
+        - positive(bool) : This is used to set the dynamicsymbol as positive,
+                    by default is False.
+        - commutative(bool) : This is used to set the commutative property of
+                    a dynamicsymbol, by default is True.
+        - integer(bool) : This is used to set the dynamicsymbol as integer,
+                    by default is False.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import dynamicsymbols
+    >>> from sympy import diff, Symbol
+    >>> q1 = dynamicsymbols('q1')
+    >>> q1
+    q1(t)
+    >>> q2 = dynamicsymbols('q2', real=True)
+    >>> q2.is_real
+    True
+    >>> q3 = dynamicsymbols('q3', positive=True)
+    >>> q3.is_positive
+    True
+    >>> q4, q5 = dynamicsymbols('q4,q5', commutative=False)
+    >>> bool(q4*q5 != q5*q4)
+    True
+    >>> q6 = dynamicsymbols('q6', integer=True)
+    >>> q6.is_integer
+    True
+    >>> diff(q1, Symbol('t'))
+    Derivative(q1(t), t)
+
+    """
+    esses = symbols(names, cls=Function, **assumptions)
+    t = dynamicsymbols._t
+    if iterable(esses):
+        esses = [reduce(diff, [t] * level, e(t)) for e in esses]
+        return esses
+    else:
+        return reduce(diff, [t] * level, esses(t))
+
+
+dynamicsymbols._t = Symbol('t')  # type: ignore
+dynamicsymbols._str = '\''  # type: ignore

venv/lib/python3.11/site-packages/sympy/physics/vector/point.py

@@ -0,0 +1,635 @@
+from .vector import Vector, _check_vector
+from .frame import _check_frame
+from warnings import warn
+from sympy.utilities.misc import filldedent
+
+__all__ = ['Point']
+
+
+class Point:
+    """This object represents a point in a dynamic system.
+
+    It stores the: position, velocity, and acceleration of a point.
+    The position is a vector defined as the vector distance from a parent
+    point to this point.
+
+    Parameters
+    ==========
+
+    name : string
+        The display name of the Point
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import Point, ReferenceFrame, dynamicsymbols
+    >>> from sympy.physics.vector import init_vprinting
+    >>> init_vprinting(pretty_print=False)
+    >>> N = ReferenceFrame('N')
+    >>> O = Point('O')
+    >>> P = Point('P')
+    >>> u1, u2, u3 = dynamicsymbols('u1 u2 u3')
+    >>> O.set_vel(N, u1 * N.x + u2 * N.y + u3 * N.z)
+    >>> O.acc(N)
+    u1'*N.x + u2'*N.y + u3'*N.z
+
+    ``symbols()`` can be used to create multiple Points in a single step, for
+    example:
+
+    >>> from sympy.physics.vector import Point, ReferenceFrame, dynamicsymbols
+    >>> from sympy.physics.vector import init_vprinting
+    >>> init_vprinting(pretty_print=False)
+    >>> from sympy import symbols
+    >>> N = ReferenceFrame('N')
+    >>> u1, u2 = dynamicsymbols('u1 u2')
+    >>> A, B = symbols('A B', cls=Point)
+    >>> type(A)
+    <class 'sympy.physics.vector.point.Point'>
+    >>> A.set_vel(N, u1 * N.x + u2 * N.y)
+    >>> B.set_vel(N, u2 * N.x + u1 * N.y)
+    >>> A.acc(N) - B.acc(N)
+    (u1' - u2')*N.x + (-u1' + u2')*N.y
+
+    """
+
+    def __init__(self, name):
+        """Initialization of a Point object. """
+        self.name = name
+        self._pos_dict = {}
+        self._vel_dict = {}
+        self._acc_dict = {}
+        self._pdlist = [self._pos_dict, self._vel_dict, self._acc_dict]
+
+    def __str__(self):
+        return self.name
+
+    __repr__ = __str__
+
+    def _check_point(self, other):
+        if not isinstance(other, Point):
+            raise TypeError('A Point must be supplied')
+
+    def _pdict_list(self, other, num):
+        """Returns a list of points that gives the shortest path with respect
+        to position, velocity, or acceleration from this point to the provided
+        point.
+
+        Parameters
+        ==========
+        other : Point
+            A point that may be related to this point by position, velocity, or
+            acceleration.
+        num : integer
+            0 for searching the position tree, 1 for searching the velocity
+            tree, and 2 for searching the acceleration tree.
+
+        Returns
+        =======
+        list of Points
+            A sequence of points from self to other.
+
+        Notes
+        =====
+
+        It is not clear if num = 1 or num = 2 actually works because the keys
+        to ``_vel_dict`` and ``_acc_dict`` are :class:`ReferenceFrame` objects
+        which do not have the ``_pdlist`` attribute.
+
+        """
+        outlist = [[self]]
+        oldlist = [[]]
+        while outlist != oldlist:
+            oldlist = outlist.copy()
+            for v in outlist:
+                templist = v[-1]._pdlist[num].keys()
+                for v2 in templist:
+                    if not v.__contains__(v2):
+                        littletemplist = v + [v2]
+                        if not outlist.__contains__(littletemplist):
+                            outlist.append(littletemplist)
+        for v in oldlist:
+            if v[-1] != other:
+                outlist.remove(v)
+        outlist.sort(key=len)
+        if len(outlist) != 0:
+            return outlist[0]
+        raise ValueError('No Connecting Path found between ' + other.name +
+                         ' and ' + self.name)
+
+    def a1pt_theory(self, otherpoint, outframe, interframe):
+        """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
+        x r^OP) + 2 ^N omega^B x ^B v^P
+
+        where O is a point fixed in B, P is a point moving in B, and B is
+        rotating in frame N.
+
+        Parameters
+        ==========
+
+        otherpoint : Point
+            The first point of the 1-point theory (O)
+        outframe : ReferenceFrame
+            The frame we want this point's acceleration defined in (N)
+        fixedframe : ReferenceFrame
+            The intermediate frame in this calculation (B)
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame
+        >>> from sympy.physics.vector import dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> q = dynamicsymbols('q')
+        >>> q2 = dynamicsymbols('q2')
+        >>> qd = dynamicsymbols('q', 1)
+        >>> q2d = dynamicsymbols('q2', 1)
+        >>> N = ReferenceFrame('N')
+        >>> B = ReferenceFrame('B')
+        >>> B.set_ang_vel(N, 5 * B.y)
+        >>> O = Point('O')
+        >>> P = O.locatenew('P', q * B.x + q2 * B.y)
+        >>> P.set_vel(B, qd * B.x + q2d * B.y)
+        >>> O.set_vel(N, 0)
+        >>> P.a1pt_theory(O, N, B)
+        (-25*q + q'')*B.x + q2''*B.y - 10*q'*B.z
+
+        """
+
+        _check_frame(outframe)
+        _check_frame(interframe)
+        self._check_point(otherpoint)
+        dist = self.pos_from(otherpoint)
+        v = self.vel(interframe)
+        a1 = otherpoint.acc(outframe)
+        a2 = self.acc(interframe)
+        omega = interframe.ang_vel_in(outframe)
+        alpha = interframe.ang_acc_in(outframe)
+        self.set_acc(outframe, a2 + 2 * (omega.cross(v)) + a1 +
+                     (alpha.cross(dist)) + (omega.cross(omega.cross(dist))))
+        return self.acc(outframe)
+
+    def a2pt_theory(self, otherpoint, outframe, fixedframe):
+        """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)
+
+        where O and P are both points fixed in frame B, which is rotating in
+        frame N.
+
+        Parameters
+        ==========
+
+        otherpoint : Point
+            The first point of the 2-point theory (O)
+        outframe : ReferenceFrame
+            The frame we want this point's acceleration defined in (N)
+        fixedframe : ReferenceFrame
+            The frame in which both points are fixed (B)
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame, dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> q = dynamicsymbols('q')
+        >>> qd = dynamicsymbols('q', 1)
+        >>> N = ReferenceFrame('N')
+        >>> B = N.orientnew('B', 'Axis', [q, N.z])
+        >>> O = Point('O')
+        >>> P = O.locatenew('P', 10 * B.x)
+        >>> O.set_vel(N, 5 * N.x)
+        >>> P.a2pt_theory(O, N, B)
+        - 10*q'**2*B.x + 10*q''*B.y
+
+        """
+
+        _check_frame(outframe)
+        _check_frame(fixedframe)
+        self._check_point(otherpoint)
+        dist = self.pos_from(otherpoint)
+        a = otherpoint.acc(outframe)
+        omega = fixedframe.ang_vel_in(outframe)
+        alpha = fixedframe.ang_acc_in(outframe)
+        self.set_acc(outframe, a + (alpha.cross(dist)) +
+                     (omega.cross(omega.cross(dist))))
+        return self.acc(outframe)
+
+    def acc(self, frame):
+        """The acceleration Vector of this Point in a ReferenceFrame.
+
+        Parameters
+        ==========
+
+        frame : ReferenceFrame
+            The frame in which the returned acceleration vector will be defined
+            in.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> p1 = Point('p1')
+        >>> p1.set_acc(N, 10 * N.x)
+        >>> p1.acc(N)
+        10*N.x
+
+        """
+
+        _check_frame(frame)
+        if not (frame in self._acc_dict):
+            if self.vel(frame) != 0:
+                return (self._vel_dict[frame]).dt(frame)
+            else:
+                return Vector(0)
+        return self._acc_dict[frame]
+
+    def locatenew(self, name, value):
+        """Creates a new point with a position defined from this point.
+
+        Parameters
+        ==========
+
+        name : str
+            The name for the new point
+        value : Vector
+            The position of the new point relative to this point
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, Point
+        >>> N = ReferenceFrame('N')
+        >>> P1 = Point('P1')
+        >>> P2 = P1.locatenew('P2', 10 * N.x)
+
+        """
+
+        if not isinstance(name, str):
+            raise TypeError('Must supply a valid name')
+        if value == 0:
+            value = Vector(0)
+        value = _check_vector(value)
+        p = Point(name)
+        p.set_pos(self, value)
+        self.set_pos(p, -value)
+        return p
+
+    def pos_from(self, otherpoint):
+        """Returns a Vector distance between this Point and the other Point.
+
+        Parameters
+        ==========
+
+        otherpoint : Point
+            The otherpoint we are locating this one relative to
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> p1 = Point('p1')
+        >>> p2 = Point('p2')
+        >>> p1.set_pos(p2, 10 * N.x)
+        >>> p1.pos_from(p2)
+        10*N.x
+
+        """
+
+        outvec = Vector(0)
+        plist = self._pdict_list(otherpoint, 0)
+        for i in range(len(plist) - 1):
+            outvec += plist[i]._pos_dict[plist[i + 1]]
+        return outvec
+
+    def set_acc(self, frame, value):
+        """Used to set the acceleration of this Point in a ReferenceFrame.
+
+        Parameters
+        ==========
+
+        frame : ReferenceFrame
+            The frame in which this point's acceleration is defined
+        value : Vector
+            The vector value of this point's acceleration in the frame
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> p1 = Point('p1')
+        >>> p1.set_acc(N, 10 * N.x)
+        >>> p1.acc(N)
+        10*N.x
+
+        """
+
+        if value == 0:
+            value = Vector(0)
+        value = _check_vector(value)
+        _check_frame(frame)
+        self._acc_dict.update({frame: value})
+
+    def set_pos(self, otherpoint, value):
+        """Used to set the position of this point w.r.t. another point.
+
+        Parameters
+        ==========
+
+        otherpoint : Point
+            The other point which this point's location is defined relative to
+        value : Vector
+            The vector which defines the location of this point
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> p1 = Point('p1')
+        >>> p2 = Point('p2')
+        >>> p1.set_pos(p2, 10 * N.x)
+        >>> p1.pos_from(p2)
+        10*N.x
+
+        """
+
+        if value == 0:
+            value = Vector(0)
+        value = _check_vector(value)
+        self._check_point(otherpoint)
+        self._pos_dict.update({otherpoint: value})
+        otherpoint._pos_dict.update({self: -value})
+
+    def set_vel(self, frame, value):
+        """Sets the velocity Vector of this Point in a ReferenceFrame.
+
+        Parameters
+        ==========
+
+        frame : ReferenceFrame
+            The frame in which this point's velocity is defined
+        value : Vector
+            The vector value of this point's velocity in the frame
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> p1 = Point('p1')
+        >>> p1.set_vel(N, 10 * N.x)
+        >>> p1.vel(N)
+        10*N.x
+
+        """
+
+        if value == 0:
+            value = Vector(0)
+        value = _check_vector(value)
+        _check_frame(frame)
+        self._vel_dict.update({frame: value})
+
+    def v1pt_theory(self, otherpoint, outframe, interframe):
+        """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
+
+        where O is a point fixed in B, P is a point moving in B, and B is
+        rotating in frame N.
+
+        Parameters
+        ==========
+
+        otherpoint : Point
+            The first point of the 1-point theory (O)
+        outframe : ReferenceFrame
+            The frame we want this point's velocity defined in (N)
+        interframe : ReferenceFrame
+            The intermediate frame in this calculation (B)
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame
+        >>> from sympy.physics.vector import dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> q = dynamicsymbols('q')
+        >>> q2 = dynamicsymbols('q2')
+        >>> qd = dynamicsymbols('q', 1)
+        >>> q2d = dynamicsymbols('q2', 1)
+        >>> N = ReferenceFrame('N')
+        >>> B = ReferenceFrame('B')
+        >>> B.set_ang_vel(N, 5 * B.y)
+        >>> O = Point('O')
+        >>> P = O.locatenew('P', q * B.x + q2 * B.y)
+        >>> P.set_vel(B, qd * B.x + q2d * B.y)
+        >>> O.set_vel(N, 0)
+        >>> P.v1pt_theory(O, N, B)
+        q'*B.x + q2'*B.y - 5*q*B.z
+
+        """
+
+        _check_frame(outframe)
+        _check_frame(interframe)
+        self._check_point(otherpoint)
+        dist = self.pos_from(otherpoint)
+        v1 = self.vel(interframe)
+        v2 = otherpoint.vel(outframe)
+        omega = interframe.ang_vel_in(outframe)
+        self.set_vel(outframe, v1 + v2 + (omega.cross(dist)))
+        return self.vel(outframe)
+
+    def v2pt_theory(self, otherpoint, outframe, fixedframe):
+        """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
+
+        where O and P are both points fixed in frame B, which is rotating in
+        frame N.
+
+        Parameters
+        ==========
+
+        otherpoint : Point
+            The first point of the 2-point theory (O)
+        outframe : ReferenceFrame
+            The frame we want this point's velocity defined in (N)
+        fixedframe : ReferenceFrame
+            The frame in which both points are fixed (B)
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame, dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> q = dynamicsymbols('q')
+        >>> qd = dynamicsymbols('q', 1)
+        >>> N = ReferenceFrame('N')
+        >>> B = N.orientnew('B', 'Axis', [q, N.z])
+        >>> O = Point('O')
+        >>> P = O.locatenew('P', 10 * B.x)
+        >>> O.set_vel(N, 5 * N.x)
+        >>> P.v2pt_theory(O, N, B)
+        5*N.x + 10*q'*B.y
+
+        """
+
+        _check_frame(outframe)
+        _check_frame(fixedframe)
+        self._check_point(otherpoint)
+        dist = self.pos_from(otherpoint)
+        v = otherpoint.vel(outframe)
+        omega = fixedframe.ang_vel_in(outframe)
+        self.set_vel(outframe, v + (omega.cross(dist)))
+        return self.vel(outframe)
+
+    def vel(self, frame):
+        """The velocity Vector of this Point in the ReferenceFrame.
+
+        Parameters
+        ==========
+
+        frame : ReferenceFrame
+            The frame in which the returned velocity vector will be defined in
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame, dynamicsymbols
+        >>> N = ReferenceFrame('N')
+        >>> p1 = Point('p1')
+        >>> p1.set_vel(N, 10 * N.x)
+        >>> p1.vel(N)
+        10*N.x
+
+        Velocities will be automatically calculated if possible, otherwise a
+        ``ValueError`` will be returned. If it is possible to calculate
+        multiple different velocities from the relative points, the points
+        defined most directly relative to this point will be used. In the case
+        of inconsistent relative positions of points, incorrect velocities may
+        be returned. It is up to the user to define prior relative positions
+        and velocities of points in a self-consistent way.
+
+        >>> p = Point('p')
+        >>> q = dynamicsymbols('q')
+        >>> p.set_vel(N, 10 * N.x)
+        >>> p2 = Point('p2')
+        >>> p2.set_pos(p, q*N.x)
+        >>> p2.vel(N)
+        (Derivative(q(t), t) + 10)*N.x
+
+        """
+
+        _check_frame(frame)
+        if not (frame in self._vel_dict):
+            valid_neighbor_found = False
+            is_cyclic = False
+            visited = []
+            queue = [self]
+            candidate_neighbor = []
+            while queue:  # BFS to find nearest point
+                node = queue.pop(0)
+                if node not in visited:
+                    visited.append(node)
+                    for neighbor, neighbor_pos in node._pos_dict.items():
+                        if neighbor in visited:
+                            continue
+                        try:
+                            # Checks if pos vector is valid
+                            neighbor_pos.express(frame)
+                        except ValueError:
+                            continue
+                        if neighbor in queue:
+                            is_cyclic = True
+                        try:
+                            # Checks if point has its vel defined in req frame
+                            neighbor_velocity = neighbor._vel_dict[frame]
+                        except KeyError:
+                            queue.append(neighbor)
+                            continue
+                        candidate_neighbor.append(neighbor)
+                        if not valid_neighbor_found:
+                            self.set_vel(frame, self.pos_from(neighbor).dt(frame) + neighbor_velocity)
+                            valid_neighbor_found = True
+            if is_cyclic:
+                warn(filldedent("""
+                Kinematic loops are defined among the positions of points. This
+                is likely not desired and may cause errors in your calculations.
+                """))
+            if len(candidate_neighbor) > 1:
+                warn(filldedent(f"""
+                Velocity of {self.name} automatically calculated based on point
+                {candidate_neighbor[0].name} but it is also possible from
+                points(s): {str(candidate_neighbor[1:])}. Velocities from these
+                points are not necessarily the same. This may cause errors in
+                your calculations."""))
+            if valid_neighbor_found:
+                return self._vel_dict[frame]
+            else:
+                raise ValueError(filldedent(f"""
+                Velocity of point {self.name} has not been defined in
+                ReferenceFrame {frame.name}."""))
+
+        return self._vel_dict[frame]
+
+    def partial_velocity(self, frame, *gen_speeds):
+        """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.
+
+        Parameters
+        ==========
+        frame : ReferenceFrame
+            The frame with which the velocity is defined in.
+        gen_speeds : functions of time
+            The generalized speeds.
+
+        Returns
+        =======
+        partial_velocities : tuple of Vector
+            The partial velocity vectors corresponding to the provided
+            generalized speeds.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, Point
+        >>> from sympy.physics.vector import dynamicsymbols
+        >>> N = ReferenceFrame('N')
+        >>> A = ReferenceFrame('A')
+        >>> p = Point('p')
+        >>> u1, u2 = dynamicsymbols('u1, u2')
+        >>> p.set_vel(N, u1 * N.x + u2 * A.y)
+        >>> p.partial_velocity(N, u1)
+        N.x
+        >>> p.partial_velocity(N, u1, u2)
+        (N.x, A.y)
+
+        """
+
+        from sympy.physics.vector.functions import partial_velocity
+
+        vel = self.vel(frame)
+        partials = partial_velocity([vel], gen_speeds, frame)[0]
+
+        if len(partials) == 1:
+            return partials[0]
+        else:
+            return tuple(partials)

venv/lib/python3.11/site-packages/sympy/physics/vector/printing.py

@@ -0,0 +1,371 @@
+from sympy.core.function import Derivative
+from sympy.core.function import UndefinedFunction, AppliedUndef
+from sympy.core.symbol import Symbol
+from sympy.interactive.printing import init_printing
+from sympy.printing.latex import LatexPrinter
+from sympy.printing.pretty.pretty import PrettyPrinter
+from sympy.printing.pretty.pretty_symbology import center_accent
+from sympy.printing.str import StrPrinter
+from sympy.printing.precedence import PRECEDENCE
+
+__all__ = ['vprint', 'vsstrrepr', 'vsprint', 'vpprint', 'vlatex',
+           'init_vprinting']
+
+
+class VectorStrPrinter(StrPrinter):
+    """String Printer for vector expressions. """
+
+    def _print_Derivative(self, e):
+        from sympy.physics.vector.functions import dynamicsymbols
+        t = dynamicsymbols._t
+        if (bool(sum(i == t for i in e.variables)) &
+                isinstance(type(e.args[0]), UndefinedFunction)):
+            ol = str(e.args[0].func)
+            for i, v in enumerate(e.variables):
+                ol += dynamicsymbols._str
+            return ol
+        else:
+            return StrPrinter().doprint(e)
+
+    def _print_Function(self, e):
+        from sympy.physics.vector.functions import dynamicsymbols
+        t = dynamicsymbols._t
+        if isinstance(type(e), UndefinedFunction):
+            return StrPrinter().doprint(e).replace("(%s)" % t, '')
+        return e.func.__name__ + "(%s)" % self.stringify(e.args, ", ")
+
+
+class VectorStrReprPrinter(VectorStrPrinter):
+    """String repr printer for vector expressions."""
+    def _print_str(self, s):
+        return repr(s)
+
+
+class VectorLatexPrinter(LatexPrinter):
+    """Latex Printer for vector expressions. """
+
+    def _print_Function(self, expr, exp=None):
+        from sympy.physics.vector.functions import dynamicsymbols
+        func = expr.func.__name__
+        t = dynamicsymbols._t
+
+        if (hasattr(self, '_print_' + func) and not
+            isinstance(type(expr), UndefinedFunction)):
+            return getattr(self, '_print_' + func)(expr, exp)
+        elif isinstance(type(expr), UndefinedFunction) and (expr.args == (t,)):
+            # treat this function like a symbol
+            expr = Symbol(func)
+            if exp is not None:
+                # copied from LatexPrinter._helper_print_standard_power, which
+                # we can't call because we only have exp as a string.
+                base = self.parenthesize(expr, PRECEDENCE['Pow'])
+                base = self.parenthesize_super(base)
+                return r"%s^{%s}" % (base, exp)
+            else:
+                return super()._print(expr)
+        else:
+            return super()._print_Function(expr, exp)
+
+    def _print_Derivative(self, der_expr):
+        from sympy.physics.vector.functions import dynamicsymbols
+        # make sure it is in the right form
+        der_expr = der_expr.doit()
+        if not isinstance(der_expr, Derivative):
+            return r"\left(%s\right)" % self.doprint(der_expr)
+
+        # check if expr is a dynamicsymbol
+        t = dynamicsymbols._t
+        expr = der_expr.expr
+        red = expr.atoms(AppliedUndef)
+        syms = der_expr.variables
+        test1 = not all(True for i in red if i.free_symbols == {t})
+        test2 = not all(t == i for i in syms)
+        if test1 or test2:
+            return super()._print_Derivative(der_expr)
+
+        # done checking
+        dots = len(syms)
+        base = self._print_Function(expr)
+        base_split = base.split('_', 1)
+        base = base_split[0]
+        if dots == 1:
+            base = r"\dot{%s}" % base
+        elif dots == 2:
+            base = r"\ddot{%s}" % base
+        elif dots == 3:
+            base = r"\dddot{%s}" % base
+        elif dots == 4:
+            base = r"\ddddot{%s}" % base
+        else:  # Fallback to standard printing
+            return super()._print_Derivative(der_expr)
+        if len(base_split) != 1:
+            base += '_' + base_split[1]
+        return base
+
+
+class VectorPrettyPrinter(PrettyPrinter):
+    """Pretty Printer for vectorialexpressions. """
+
+    def _print_Derivative(self, deriv):
+        from sympy.physics.vector.functions import dynamicsymbols
+        # XXX use U('PARTIAL DIFFERENTIAL') here ?
+        t = dynamicsymbols._t
+        dot_i = 0
+        syms = list(reversed(deriv.variables))
+
+        while len(syms) > 0:
+            if syms[-1] == t:
+                syms.pop()
+                dot_i += 1
+            else:
+                return super()._print_Derivative(deriv)
+
+        if not (isinstance(type(deriv.expr), UndefinedFunction) and
+                (deriv.expr.args == (t,))):
+            return super()._print_Derivative(deriv)
+        else:
+            pform = self._print_Function(deriv.expr)
+
+        # the following condition would happen with some sort of non-standard
+        # dynamic symbol I guess, so we'll just print the SymPy way
+        if len(pform.picture) > 1:
+            return super()._print_Derivative(deriv)
+
+        # There are only special symbols up to fourth-order derivatives
+        if dot_i >= 5:
+            return super()._print_Derivative(deriv)
+
+        # Deal with special symbols
+        dots = {0: "",
+                1: "\N{COMBINING DOT ABOVE}",
+                2: "\N{COMBINING DIAERESIS}",
+                3: "\N{COMBINING THREE DOTS ABOVE}",
+                4: "\N{COMBINING FOUR DOTS ABOVE}"}
+
+        d = pform.__dict__
+        # if unicode is false then calculate number of apostrophes needed and
+        # add to output
+        if not self._use_unicode:
+            apostrophes = ""
+            for i in range(0, dot_i):
+                apostrophes += "'"
+            d['picture'][0] += apostrophes + "(t)"
+        else:
+            d['picture'] = [center_accent(d['picture'][0], dots[dot_i])]
+        return pform
+
+    def _print_Function(self, e):
+        from sympy.physics.vector.functions import dynamicsymbols
+        t = dynamicsymbols._t
+        # XXX works only for applied functions
+        func = e.func
+        args = e.args
+        func_name = func.__name__
+        pform = self._print_Symbol(Symbol(func_name))
+        # If this function is an Undefined function of t, it is probably a
+        # dynamic symbol, so we'll skip the (t). The rest of the code is
+        # identical to the normal PrettyPrinter code
+        if not (isinstance(func, UndefinedFunction) and (args == (t,))):
+            return super()._print_Function(e)
+        return pform
+
+
+def vprint(expr, **settings):
+    r"""Function for printing of expressions generated in the
+    sympy.physics vector package.
+
+    Extends SymPy's StrPrinter, takes the same setting accepted by SymPy's
+    :func:`~.sstr`, and is equivalent to ``print(sstr(foo))``.
+
+    Parameters
+    ==========
+
+    expr : valid SymPy object
+        SymPy expression to print.
+    settings : args
+        Same as the settings accepted by SymPy's sstr().
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import vprint, dynamicsymbols
+    >>> u1 = dynamicsymbols('u1')
+    >>> print(u1)
+    u1(t)
+    >>> vprint(u1)
+    u1
+
+    """
+
+    outstr = vsprint(expr, **settings)
+
+    import builtins
+    if (outstr != 'None'):
+        builtins._ = outstr
+        print(outstr)
+
+
+def vsstrrepr(expr, **settings):
+    """Function for displaying expression representation's with vector
+    printing enabled.
+
+    Parameters
+    ==========
+
+    expr : valid SymPy object
+        SymPy expression to print.
+    settings : args
+        Same as the settings accepted by SymPy's sstrrepr().
+
+    """
+    p = VectorStrReprPrinter(settings)
+    return p.doprint(expr)
+
+
+def vsprint(expr, **settings):
+    r"""Function for displaying expressions generated in the
+    sympy.physics vector package.
+
+    Returns the output of vprint() as a string.
+
+    Parameters
+    ==========
+
+    expr : valid SymPy object
+        SymPy expression to print
+    settings : args
+        Same as the settings accepted by SymPy's sstr().
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import vsprint, dynamicsymbols
+    >>> u1, u2 = dynamicsymbols('u1 u2')
+    >>> u2d = dynamicsymbols('u2', level=1)
+    >>> print("%s = %s" % (u1, u2 + u2d))
+    u1(t) = u2(t) + Derivative(u2(t), t)
+    >>> print("%s = %s" % (vsprint(u1), vsprint(u2 + u2d)))
+    u1 = u2 + u2'
+
+    """
+
+    string_printer = VectorStrPrinter(settings)
+    return string_printer.doprint(expr)
+
+
+def vpprint(expr, **settings):
+    r"""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
+    scripts and generating equations of motion. Takes the same options as
+    SymPy's :func:`~.pretty_print`; see that function for more information.
+
+    Parameters
+    ==========
+
+    expr : valid SymPy object
+        SymPy expression to pretty print
+    settings : args
+        Same as those accepted by SymPy's pretty_print.
+
+
+    """
+
+    pp = VectorPrettyPrinter(settings)
+
+    # Note that this is copied from sympy.printing.pretty.pretty_print:
+
+    # XXX: this is an ugly hack, but at least it works
+    use_unicode = pp._settings['use_unicode']
+    from sympy.printing.pretty.pretty_symbology import pretty_use_unicode
+    uflag = pretty_use_unicode(use_unicode)
+
+    try:
+        return pp.doprint(expr)
+    finally:
+        pretty_use_unicode(uflag)
+
+
+def vlatex(expr, **settings):
+    r"""Function for printing latex representation of sympy.physics.vector
+    objects.
+
+    For latex representation of Vectors, Dyadics, and dynamicsymbols. Takes the
+    same options as SymPy's :func:`~.latex`; see that function for more
+    information;
+
+    Parameters
+    ==========
+
+    expr : valid SymPy object
+        SymPy expression to represent in LaTeX form
+    settings : args
+        Same as latex()
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import vlatex, ReferenceFrame, dynamicsymbols
+    >>> N = ReferenceFrame('N')
+    >>> q1, q2 = dynamicsymbols('q1 q2')
+    >>> q1d, q2d = dynamicsymbols('q1 q2', 1)
+    >>> q1dd, q2dd = dynamicsymbols('q1 q2', 2)
+    >>> vlatex(N.x + N.y)
+    '\\mathbf{\\hat{n}_x} + \\mathbf{\\hat{n}_y}'
+    >>> vlatex(q1 + q2)
+    'q_{1} + q_{2}'
+    >>> vlatex(q1d)
+    '\\dot{q}_{1}'
+    >>> vlatex(q1 * q2d)
+    'q_{1} \\dot{q}_{2}'
+    >>> vlatex(q1dd * q1 / q1d)
+    '\\frac{q_{1} \\ddot{q}_{1}}{\\dot{q}_{1}}'
+
+    """
+    latex_printer = VectorLatexPrinter(settings)
+
+    return latex_printer.doprint(expr)
+
+
+def init_vprinting(**kwargs):
+    """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
+    displaying as ``Derivative(f(t),t)``, it will display ``f'``. This is
+    only actually needed for when derivatives are present and are not in a
+    physics.vector.Vector or physics.vector.Dyadic object. This function is a
+    light wrapper to :func:`~.init_printing`. Any keyword
+    arguments for it are valid here.
+
+    {0}
+
+    Examples
+    ========
+
+    >>> from sympy import Function, symbols
+    >>> t, x = symbols('t, x')
+    >>> omega = Function('omega')
+    >>> omega(x).diff()
+    Derivative(omega(x), x)
+    >>> omega(t).diff()
+    Derivative(omega(t), t)
+
+    Now use the string printer:
+
+    >>> from sympy.physics.vector import init_vprinting
+    >>> init_vprinting(pretty_print=False)
+    >>> omega(x).diff()
+    Derivative(omega(x), x)
+    >>> omega(t).diff()
+    omega'
+
+    """
+    kwargs['str_printer'] = vsstrrepr
+    kwargs['pretty_printer'] = vpprint
+    kwargs['latex_printer'] = vlatex
+    init_printing(**kwargs)
+
+
+params = init_printing.__doc__.split('Examples\n    ========')[0]  # type: ignore
+init_vprinting.__doc__ = init_vprinting.__doc__.format(params)  # type: ignore

venv/lib/python3.11/site-packages/sympy/physics/vector/tests/test_dyadic.py

@@ -0,0 +1,123 @@
+from sympy.core.numbers import (Float, pi)
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.matrices.immutable import ImmutableDenseMatrix as Matrix
+from sympy.physics.vector import ReferenceFrame, dynamicsymbols, outer
+from sympy.physics.vector.dyadic import _check_dyadic
+from sympy.testing.pytest import raises
+
+A = ReferenceFrame('A')
+
+
+def test_dyadic():
+    d1 = A.x | A.x
+    d2 = A.y | A.y
+    d3 = A.x | A.y
+    assert d1 * 0 == 0
+    assert d1 != 0
+    assert d1 * 2 == 2 * A.x | A.x
+    assert d1 / 2. == 0.5 * d1
+    assert d1 & (0 * d1) == 0
+    assert d1 & d2 == 0
+    assert d1 & A.x == A.x
+    assert d1 ^ A.x == 0
+    assert d1 ^ A.y == A.x | A.z
+    assert d1 ^ A.z == - A.x | A.y
+    assert d2 ^ A.x == - A.y | A.z
+    assert A.x ^ d1 == 0
+    assert A.y ^ d1 == - A.z | A.x
+    assert A.z ^ d1 == A.y | A.x
+    assert A.x & d1 == A.x
+    assert A.y & d1 == 0
+    assert A.y & d2 == A.y
+    assert d1 & d3 == A.x | A.y
+    assert d3 & d1 == 0
+    assert d1.dt(A) == 0
+    q = dynamicsymbols('q')
+    qd = dynamicsymbols('q', 1)
+    B = A.orientnew('B', 'Axis', [q, A.z])
+    assert d1.express(B) == d1.express(B, B)
+    assert d1.express(B) == ((cos(q)**2) * (B.x | B.x) + (-sin(q) * cos(q)) *
+            (B.x | B.y) + (-sin(q) * cos(q)) * (B.y | B.x) + (sin(q)**2) *
+            (B.y | B.y))
+    assert d1.express(B, A) == (cos(q)) * (B.x | A.x) + (-sin(q)) * (B.y | A.x)
+    assert d1.express(A, B) == (cos(q)) * (A.x | B.x) + (-sin(q)) * (A.x | B.y)
+    assert d1.dt(B) == (-qd) * (A.y | A.x) + (-qd) * (A.x | A.y)
+
+    assert d1.to_matrix(A) == Matrix([[1, 0, 0], [0, 0, 0], [0, 0, 0]])
+    assert d1.to_matrix(A, B) == Matrix([[cos(q), -sin(q), 0],
+                                         [0, 0, 0],
+                                         [0, 0, 0]])
+    assert d3.to_matrix(A) == Matrix([[0, 1, 0], [0, 0, 0], [0, 0, 0]])
+    a, b, c, d, e, f = symbols('a, b, c, d, e, f')
+    v1 = a * A.x + b * A.y + c * A.z
+    v2 = d * A.x + e * A.y + f * A.z
+    d4 = v1.outer(v2)
+    assert d4.to_matrix(A) == Matrix([[a * d, a * e, a * f],
+                                      [b * d, b * e, b * f],
+                                      [c * d, c * e, c * f]])
+    d5 = v1.outer(v1)
+    C = A.orientnew('C', 'Axis', [q, A.x])
+    for expected, actual in zip(C.dcm(A) * d5.to_matrix(A) * C.dcm(A).T,
+                                d5.to_matrix(C)):
+        assert (expected - actual).simplify() == 0
+
+    raises(TypeError, lambda: d1.applyfunc(0))
+
+
+def test_dyadic_simplify():
+    x, y, z, k, n, m, w, f, s, A = symbols('x, y, z, k, n, m, w, f, s, A')
+    N = ReferenceFrame('N')
+
+    dy = N.x | N.x
+    test1 = (1 / x + 1 / y) * dy
+    assert (N.x & test1 & N.x) != (x + y) / (x * y)
+    test1 = test1.simplify()
+    assert (N.x & test1 & N.x) == (x + y) / (x * y)
+
+    test2 = (A**2 * s**4 / (4 * pi * k * m**3)) * dy
+    test2 = test2.simplify()
+    assert (N.x & test2 & N.x) == (A**2 * s**4 / (4 * pi * k * m**3))
+
+    test3 = ((4 + 4 * x - 2 * (2 + 2 * x)) / (2 + 2 * x)) * dy
+    test3 = test3.simplify()
+    assert (N.x & test3 & N.x) == 0
+
+    test4 = ((-4 * x * y**2 - 2 * y**3 - 2 * x**2 * y) / (x + y)**2) * dy
+    test4 = test4.simplify()
+    assert (N.x & test4 & N.x) == -2 * y
+
+
+def test_dyadic_subs():
+    N = ReferenceFrame('N')
+    s = symbols('s')
+    a = s*(N.x | N.x)
+    assert a.subs({s: 2}) == 2*(N.x | N.x)
+
+
+def test_check_dyadic():
+    raises(TypeError, lambda: _check_dyadic(0))
+
+
+def test_dyadic_evalf():
+    N = ReferenceFrame('N')
+    a = pi * (N.x | N.x)
+    assert a.evalf(3) == Float('3.1416', 3) * (N.x | N.x)
+    s = symbols('s')
+    a = 5 * s * pi* (N.x | N.x)
+    assert a.evalf(2) == Float('5', 2) * Float('3.1416', 2) * s * (N.x | N.x)
+    assert a.evalf(9, subs={s: 5.124}) == Float('80.48760378', 9) * (N.x | N.x)
+
+
+def test_dyadic_xreplace():
+    x, y, z = symbols('x y z')
+    N = ReferenceFrame('N')
+    D = outer(N.x, N.x)
+    v = x*y * D
+    assert v.xreplace({x : cos(x)}) == cos(x)*y * D
+    assert v.xreplace({x*y : pi}) == pi * D
+    v = (x*y)**z * D
+    assert v.xreplace({(x*y)**z : 1}) == D
+    assert v.xreplace({x:1, z:0}) == D
+    raises(TypeError, lambda: v.xreplace())
+    raises(TypeError, lambda: v.xreplace([x, y]))

venv/lib/python3.11/site-packages/sympy/physics/vector/tests/test_fieldfunctions.py

@@ -0,0 +1,133 @@
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.physics.vector import ReferenceFrame, Vector, Point, \
+     dynamicsymbols
+from sympy.physics.vector.fieldfunctions import divergence, \
+     gradient, curl, is_conservative, is_solenoidal, \
+     scalar_potential, scalar_potential_difference
+from sympy.testing.pytest import raises
+
+R = ReferenceFrame('R')
+q = dynamicsymbols('q')
+P = R.orientnew('P', 'Axis', [q, R.z])
+
+
+def test_curl():
+    assert curl(Vector(0), R) == Vector(0)
+    assert curl(R.x, R) == Vector(0)
+    assert curl(2*R[1]**2*R.y, R) == Vector(0)
+    assert curl(R[0]*R[1]*R.z, R) == R[0]*R.x - R[1]*R.y
+    assert curl(R[0]*R[1]*R[2] * (R.x+R.y+R.z), R) == \
+           (-R[0]*R[1] + R[0]*R[2])*R.x + (R[0]*R[1] - R[1]*R[2])*R.y + \
+           (-R[0]*R[2] + R[1]*R[2])*R.z
+    assert curl(2*R[0]**2*R.y, R) == 4*R[0]*R.z
+    assert curl(P[0]**2*R.x + P.y, R) == \
+           - 2*(R[0]*cos(q) + R[1]*sin(q))*sin(q)*R.z
+    assert curl(P[0]*R.y, P) == cos(q)*P.z
+
+
+def test_divergence():
+    assert divergence(Vector(0), R) is S.Zero
+    assert divergence(R.x, R) is S.Zero
+    assert divergence(R[0]**2*R.x, R) == 2*R[0]
+    assert divergence(R[0]*R[1]*R[2] * (R.x+R.y+R.z), R) == \
+           R[0]*R[1] + R[0]*R[2] + R[1]*R[2]
+    assert divergence((1/(R[0]*R[1]*R[2])) * (R.x+R.y+R.z), R) == \
+           -1/(R[0]*R[1]*R[2]**2) - 1/(R[0]*R[1]**2*R[2]) - \
+           1/(R[0]**2*R[1]*R[2])
+    v = P[0]*P.x + P[1]*P.y + P[2]*P.z
+    assert divergence(v, P) == 3
+    assert divergence(v, R).simplify() == 3
+    assert divergence(P[0]*R.x + R[0]*P.x, R) == 2*cos(q)
+
+
+def test_gradient():
+    a = Symbol('a')
+    assert gradient(0, R) == Vector(0)
+    assert gradient(R[0], R) == R.x
+    assert gradient(R[0]*R[1]*R[2], R) == \
+           R[1]*R[2]*R.x + R[0]*R[2]*R.y + R[0]*R[1]*R.z
+    assert gradient(2*R[0]**2, R) == 4*R[0]*R.x
+    assert gradient(a*sin(R[1])/R[0], R) == \
+           - a*sin(R[1])/R[0]**2*R.x + a*cos(R[1])/R[0]*R.y
+    assert gradient(P[0]*P[1], R) == \
+           ((-R[0]*sin(q) + R[1]*cos(q))*cos(q) - (R[0]*cos(q) + R[1]*sin(q))*sin(q))*R.x + \
+           ((-R[0]*sin(q) + R[1]*cos(q))*sin(q) + (R[0]*cos(q) + R[1]*sin(q))*cos(q))*R.y
+    assert gradient(P[0]*R[2], P) == P[2]*P.x + P[0]*P.z
+
+
+scalar_field = 2*R[0]**2*R[1]*R[2]
+grad_field = gradient(scalar_field, R)
+vector_field = R[1]**2*R.x + 3*R[0]*R.y + 5*R[1]*R[2]*R.z
+curl_field = curl(vector_field, R)
+
+
+def test_conservative():
+    assert is_conservative(0) is True
+    assert is_conservative(R.x) is True
+    assert is_conservative(2 * R.x + 3 * R.y + 4 * R.z) is True
+    assert is_conservative(R[1]*R[2]*R.x + R[0]*R[2]*R.y + R[0]*R[1]*R.z) is \
+           True
+    assert is_conservative(R[0] * R.y) is False
+    assert is_conservative(grad_field) is True
+    assert is_conservative(curl_field) is False
+    assert is_conservative(4*R[0]*R[1]*R[2]*R.x + 2*R[0]**2*R[2]*R.y) is \
+                           False
+    assert is_conservative(R[2]*P.x + P[0]*R.z) is True
+
+
+def test_solenoidal():
+    assert is_solenoidal(0) is True
+    assert is_solenoidal(R.x) is True
+    assert is_solenoidal(2 * R.x + 3 * R.y + 4 * R.z) is True
+    assert is_solenoidal(R[1]*R[2]*R.x + R[0]*R[2]*R.y + R[0]*R[1]*R.z) is \
+           True
+    assert is_solenoidal(R[1] * R.y) is False
+    assert is_solenoidal(grad_field) is False
+    assert is_solenoidal(curl_field) is True
+    assert is_solenoidal((-2*R[1] + 3)*R.z) is True
+    assert is_solenoidal(cos(q)*R.x + sin(q)*R.y + cos(q)*P.z) is True
+    assert is_solenoidal(R[2]*P.x + P[0]*R.z) is True
+
+
+def test_scalar_potential():
+    assert scalar_potential(0, R) == 0
+    assert scalar_potential(R.x, R) == R[0]
+    assert scalar_potential(R.y, R) == R[1]
+    assert scalar_potential(R.z, R) == R[2]
+    assert scalar_potential(R[1]*R[2]*R.x + R[0]*R[2]*R.y + \
+                            R[0]*R[1]*R.z, R) == R[0]*R[1]*R[2]
+    assert scalar_potential(grad_field, R) == scalar_field
+    assert scalar_potential(R[2]*P.x + P[0]*R.z, R) == \
+           R[0]*R[2]*cos(q) + R[1]*R[2]*sin(q)
+    assert scalar_potential(R[2]*P.x + P[0]*R.z, P) == P[0]*P[2]
+    raises(ValueError, lambda: scalar_potential(R[0] * R.y, R))
+
+
+def test_scalar_potential_difference():
+    origin = Point('O')
+    point1 = origin.locatenew('P1', 1*R.x + 2*R.y + 3*R.z)
+    point2 = origin.locatenew('P2', 4*R.x + 5*R.y + 6*R.z)
+    genericpointR = origin.locatenew('RP', R[0]*R.x + R[1]*R.y + R[2]*R.z)
+    genericpointP = origin.locatenew('PP', P[0]*P.x + P[1]*P.y + P[2]*P.z)
+    assert scalar_potential_difference(S.Zero, R, point1, point2, \
+                                       origin) == 0
+    assert scalar_potential_difference(scalar_field, R, origin, \
+                                       genericpointR, origin) == \
+                                       scalar_field
+    assert scalar_potential_difference(grad_field, R, origin, \
+                                       genericpointR, origin) == \
+                                       scalar_field
+    assert scalar_potential_difference(grad_field, R, point1, point2,
+                                       origin) == 948
+    assert scalar_potential_difference(R[1]*R[2]*R.x + R[0]*R[2]*R.y + \
+                                       R[0]*R[1]*R.z, R, point1,
+                                       genericpointR, origin) == \
+                                       R[0]*R[1]*R[2] - 6
+    potential_diff_P = 2*P[2]*(P[0]*sin(q) + P[1]*cos(q))*\
+                       (P[0]*cos(q) - P[1]*sin(q))**2
+    assert scalar_potential_difference(grad_field, P, origin, \
+                                       genericpointP, \
+                                       origin).simplify() == \
+                                       potential_diff_P

venv/lib/python3.11/site-packages/sympy/physics/vector/tests/test_frame.py

@@ -0,0 +1,761 @@
+from sympy.core.numbers import pi
+from sympy.core.symbol import symbols
+from sympy.simplify import trigsimp
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.matrices.dense import (eye, zeros)
+from sympy.matrices.immutable import ImmutableDenseMatrix as Matrix
+from sympy.simplify.simplify import simplify
+from sympy.physics.vector import (ReferenceFrame, Vector, CoordinateSym,
+                                  dynamicsymbols, time_derivative, express,
+                                  dot)
+from sympy.physics.vector.frame import _check_frame
+from sympy.physics.vector.vector import VectorTypeError
+from sympy.testing.pytest import raises
+import warnings
+import pickle
+
+
+def test_dict_list():
+
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    C = ReferenceFrame('C')
+    D = ReferenceFrame('D')
+    E = ReferenceFrame('E')
+    F = ReferenceFrame('F')
+
+    B.orient_axis(A, A.x, 1.0)
+    C.orient_axis(B, B.x, 1.0)
+    D.orient_axis(C, C.x, 1.0)
+
+    assert D._dict_list(A, 0) == [D, C, B, A]
+
+    E.orient_axis(D, D.x, 1.0)
+
+    assert C._dict_list(A, 0) == [C, B, A]
+    assert C._dict_list(E, 0) == [C, D, E]
+
+    # only 0, 1, 2 permitted for second argument
+    raises(ValueError, lambda: C._dict_list(E, 5))
+    # no connecting path
+    raises(ValueError, lambda: F._dict_list(A, 0))
+
+
+def test_coordinate_vars():
+    """Tests the coordinate variables functionality"""
+    A = ReferenceFrame('A')
+    assert CoordinateSym('Ax', A, 0) == A[0]
+    assert CoordinateSym('Ax', A, 1) == A[1]
+    assert CoordinateSym('Ax', A, 2) == A[2]
+    raises(ValueError, lambda: CoordinateSym('Ax', A, 3))
+    q = dynamicsymbols('q')
+    qd = dynamicsymbols('q', 1)
+    assert isinstance(A[0], CoordinateSym) and \
+           isinstance(A[0], CoordinateSym) and \
+           isinstance(A[0], CoordinateSym)
+    assert A.variable_map(A) == {A[0]:A[0], A[1]:A[1], A[2]:A[2]}
+    assert A[0].frame == A
+    B = A.orientnew('B', 'Axis', [q, A.z])
+    assert B.variable_map(A) == {B[2]: A[2], B[1]: -A[0]*sin(q) + A[1]*cos(q),
+                                 B[0]: A[0]*cos(q) + A[1]*sin(q)}
+    assert A.variable_map(B) == {A[0]: B[0]*cos(q) - B[1]*sin(q),
+                                 A[1]: B[0]*sin(q) + B[1]*cos(q), A[2]: B[2]}
+    assert time_derivative(B[0], A) == -A[0]*sin(q)*qd + A[1]*cos(q)*qd
+    assert time_derivative(B[1], A) == -A[0]*cos(q)*qd - A[1]*sin(q)*qd
+    assert time_derivative(B[2], A) == 0
+    assert express(B[0], A, variables=True) == A[0]*cos(q) + A[1]*sin(q)
+    assert express(B[1], A, variables=True) == -A[0]*sin(q) + A[1]*cos(q)
+    assert express(B[2], A, variables=True) == A[2]
+    assert time_derivative(A[0]*A.x + A[1]*A.y + A[2]*A.z, B) == A[1]*qd*A.x - A[0]*qd*A.y
+    assert time_derivative(B[0]*B.x + B[1]*B.y + B[2]*B.z, A) == - B[1]*qd*B.x + B[0]*qd*B.y
+    assert express(B[0]*B[1]*B[2], A, variables=True) == \
+           A[2]*(-A[0]*sin(q) + A[1]*cos(q))*(A[0]*cos(q) + A[1]*sin(q))
+    assert (time_derivative(B[0]*B[1]*B[2], A) -
+            (A[2]*(-A[0]**2*cos(2*q) -
+             2*A[0]*A[1]*sin(2*q) +
+             A[1]**2*cos(2*q))*qd)).trigsimp() == 0
+    assert express(B[0]*B.x + B[1]*B.y + B[2]*B.z, A) == \
+           (B[0]*cos(q) - B[1]*sin(q))*A.x + (B[0]*sin(q) + \
+           B[1]*cos(q))*A.y + B[2]*A.z
+    assert express(B[0]*B.x + B[1]*B.y + B[2]*B.z, A,
+                   variables=True).simplify() == A[0]*A.x + A[1]*A.y + A[2]*A.z
+    assert express(A[0]*A.x + A[1]*A.y + A[2]*A.z, B) == \
+           (A[0]*cos(q) + A[1]*sin(q))*B.x + \
+           (-A[0]*sin(q) + A[1]*cos(q))*B.y + A[2]*B.z
+    assert express(A[0]*A.x + A[1]*A.y + A[2]*A.z, B,
+                   variables=True).simplify() == B[0]*B.x + B[1]*B.y + B[2]*B.z
+    N = B.orientnew('N', 'Axis', [-q, B.z])
+    assert ({k: v.simplify() for k, v in N.variable_map(A).items()} ==
+            {N[0]: A[0], N[2]: A[2], N[1]: A[1]})
+    C = A.orientnew('C', 'Axis', [q, A.x + A.y + A.z])
+    mapping = A.variable_map(C)
+    assert trigsimp(mapping[A[0]]) == (2*C[0]*cos(q)/3 + C[0]/3 -
+                                       2*C[1]*sin(q + pi/6)/3 +
+                                       C[1]/3 - 2*C[2]*cos(q + pi/3)/3 +
+                                       C[2]/3)
+    assert trigsimp(mapping[A[1]]) == -2*C[0]*cos(q + pi/3)/3 + \
+           C[0]/3 + 2*C[1]*cos(q)/3 + C[1]/3 - 2*C[2]*sin(q + pi/6)/3 + C[2]/3
+    assert trigsimp(mapping[A[2]]) == -2*C[0]*sin(q + pi/6)/3 + C[0]/3 - \
+           2*C[1]*cos(q + pi/3)/3 + C[1]/3 + 2*C[2]*cos(q)/3 + C[2]/3
+
+
+def test_ang_vel():
+    q1, q2, q3, q4 = dynamicsymbols('q1 q2 q3 q4')
+    q1d, q2d, q3d, q4d = dynamicsymbols('q1 q2 q3 q4', 1)
+    N = ReferenceFrame('N')
+    A = N.orientnew('A', 'Axis', [q1, N.z])
+    B = A.orientnew('B', 'Axis', [q2, A.x])
+    C = B.orientnew('C', 'Axis', [q3, B.y])
+    D = N.orientnew('D', 'Axis', [q4, N.y])
+    u1, u2, u3 = dynamicsymbols('u1 u2 u3')
+    assert A.ang_vel_in(N) == (q1d)*A.z
+    assert B.ang_vel_in(N) == (q2d)*B.x + (q1d)*A.z
+    assert C.ang_vel_in(N) == (q3d)*C.y + (q2d)*B.x + (q1d)*A.z
+
+    A2 = N.orientnew('A2', 'Axis', [q4, N.y])
+    assert N.ang_vel_in(N) == 0
+    assert N.ang_vel_in(A) == -q1d*N.z
+    assert N.ang_vel_in(B) == -q1d*A.z - q2d*B.x
+    assert N.ang_vel_in(C) == -q1d*A.z - q2d*B.x - q3d*B.y
+    assert N.ang_vel_in(A2) == -q4d*N.y
+
+    assert A.ang_vel_in(N) == q1d*N.z
+    assert A.ang_vel_in(A) == 0
+    assert A.ang_vel_in(B) == - q2d*B.x
+    assert A.ang_vel_in(C) == - q2d*B.x - q3d*B.y
+    assert A.ang_vel_in(A2) == q1d*N.z - q4d*N.y
+
+    assert B.ang_vel_in(N) == q1d*A.z + q2d*A.x
+    assert B.ang_vel_in(A) == q2d*A.x
+    assert B.ang_vel_in(B) == 0
+    assert B.ang_vel_in(C) == -q3d*B.y
+    assert B.ang_vel_in(A2) == q1d*A.z + q2d*A.x - q4d*N.y
+
+    assert C.ang_vel_in(N) == q1d*A.z + q2d*A.x + q3d*B.y
+    assert C.ang_vel_in(A) == q2d*A.x + q3d*C.y
+    assert C.ang_vel_in(B) == q3d*B.y
+    assert C.ang_vel_in(C) == 0
+    assert C.ang_vel_in(A2) == q1d*A.z + q2d*A.x + q3d*B.y - q4d*N.y
+
+    assert A2.ang_vel_in(N) == q4d*A2.y
+    assert A2.ang_vel_in(A) == q4d*A2.y - q1d*N.z
+    assert A2.ang_vel_in(B) == q4d*N.y - q1d*A.z - q2d*A.x
+    assert A2.ang_vel_in(C) == q4d*N.y - q1d*A.z - q2d*A.x - q3d*B.y
+    assert A2.ang_vel_in(A2) == 0
+
+    C.set_ang_vel(N, u1*C.x + u2*C.y + u3*C.z)
+    assert C.ang_vel_in(N) == (u1)*C.x + (u2)*C.y + (u3)*C.z
+    assert N.ang_vel_in(C) == (-u1)*C.x + (-u2)*C.y + (-u3)*C.z
+    assert C.ang_vel_in(D) == (u1)*C.x + (u2)*C.y + (u3)*C.z + (-q4d)*D.y
+    assert D.ang_vel_in(C) == (-u1)*C.x + (-u2)*C.y + (-u3)*C.z + (q4d)*D.y
+
+    q0 = dynamicsymbols('q0')
+    q0d = dynamicsymbols('q0', 1)
+    E = N.orientnew('E', 'Quaternion', (q0, q1, q2, q3))
+    assert E.ang_vel_in(N) == (
+        2 * (q1d * q0 + q2d * q3 - q3d * q2 - q0d * q1) * E.x +
+        2 * (q2d * q0 + q3d * q1 - q1d * q3 - q0d * q2) * E.y +
+        2 * (q3d * q0 + q1d * q2 - q2d * q1 - q0d * q3) * E.z)
+
+    F = N.orientnew('F', 'Body', (q1, q2, q3), 313)
+    assert F.ang_vel_in(N) == ((sin(q2)*sin(q3)*q1d + cos(q3)*q2d)*F.x +
+        (sin(q2)*cos(q3)*q1d - sin(q3)*q2d)*F.y + (cos(q2)*q1d + q3d)*F.z)
+    G = N.orientnew('G', 'Axis', (q1, N.x + N.y))
+    assert G.ang_vel_in(N) == q1d * (N.x + N.y).normalize()
+    assert N.ang_vel_in(G) == -q1d * (N.x + N.y).normalize()
+
+
+def test_dcm():
+    q1, q2, q3, q4 = dynamicsymbols('q1 q2 q3 q4')
+    N = ReferenceFrame('N')
+    A = N.orientnew('A', 'Axis', [q1, N.z])
+    B = A.orientnew('B', 'Axis', [q2, A.x])
+    C = B.orientnew('C', 'Axis', [q3, B.y])
+    D = N.orientnew('D', 'Axis', [q4, N.y])
+    E = N.orientnew('E', 'Space', [q1, q2, q3], '123')
+    assert N.dcm(C) == Matrix([
+        [- sin(q1) * sin(q2) * sin(q3) + cos(q1) * cos(q3), - sin(q1) *
+        cos(q2), sin(q1) * sin(q2) * cos(q3) + sin(q3) * cos(q1)], [sin(q1) *
+        cos(q3) + sin(q2) * sin(q3) * cos(q1), cos(q1) * cos(q2), sin(q1) *
+            sin(q3) - sin(q2) * cos(q1) * cos(q3)], [- sin(q3) * cos(q2), sin(q2),
+        cos(q2) * cos(q3)]])
+    # This is a little touchy.  Is it ok to use simplify in assert?
+    test_mat = D.dcm(C) - Matrix(
+        [[cos(q1) * cos(q3) * cos(q4) - sin(q3) * (- sin(q4) * cos(q2) +
+        sin(q1) * sin(q2) * cos(q4)), - sin(q2) * sin(q4) - sin(q1) *
+            cos(q2) * cos(q4), sin(q3) * cos(q1) * cos(q4) + cos(q3) * (- sin(q4) *
+        cos(q2) + sin(q1) * sin(q2) * cos(q4))], [sin(q1) * cos(q3) +
+        sin(q2) * sin(q3) * cos(q1), cos(q1) * cos(q2), sin(q1) * sin(q3) -
+            sin(q2) * cos(q1) * cos(q3)], [sin(q4) * cos(q1) * cos(q3) -
+        sin(q3) * (cos(q2) * cos(q4) + sin(q1) * sin(q2) * sin(q4)), sin(q2) *
+                cos(q4) - sin(q1) * sin(q4) * cos(q2), sin(q3) * sin(q4) * cos(q1) +
+                cos(q3) * (cos(q2) * cos(q4) + sin(q1) * sin(q2) * sin(q4))]])
+    assert test_mat.expand() == zeros(3, 3)
+    assert E.dcm(N) == Matrix(
+        [[cos(q2)*cos(q3), sin(q3)*cos(q2), -sin(q2)],
+        [sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1), sin(q1)*sin(q2)*sin(q3) +
+        cos(q1)*cos(q3), sin(q1)*cos(q2)], [sin(q1)*sin(q3) +
+        sin(q2)*cos(q1)*cos(q3), - sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1),
+         cos(q1)*cos(q2)]])
+
+def test_w_diff_dcm1():
+    # Ref:
+    # Dynamics Theory and Applications, Kane 1985
+    # Sec. 2.1 ANGULAR VELOCITY
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+
+    c11, c12, c13 = dynamicsymbols('C11 C12 C13')
+    c21, c22, c23 = dynamicsymbols('C21 C22 C23')
+    c31, c32, c33 = dynamicsymbols('C31 C32 C33')
+
+    c11d, c12d, c13d = dynamicsymbols('C11 C12 C13', level=1)
+    c21d, c22d, c23d = dynamicsymbols('C21 C22 C23', level=1)
+    c31d, c32d, c33d = dynamicsymbols('C31 C32 C33', level=1)
+
+    DCM = Matrix([
+        [c11, c12, c13],
+        [c21, c22, c23],
+        [c31, c32, c33]
+    ])
+
+    B.orient(A, 'DCM', DCM)
+    b1a = (B.x).express(A)
+    b2a = (B.y).express(A)
+    b3a = (B.z).express(A)
+
+    # Equation (2.1.1)
+    B.set_ang_vel(A, B.x*(dot((b3a).dt(A), B.y))
+                   + B.y*(dot((b1a).dt(A), B.z))
+                   + B.z*(dot((b2a).dt(A), B.x)))
+
+    # Equation (2.1.21)
+    expr = (  (c12*c13d + c22*c23d + c32*c33d)*B.x
+            + (c13*c11d + c23*c21d + c33*c31d)*B.y
+            + (c11*c12d + c21*c22d + c31*c32d)*B.z)
+    assert B.ang_vel_in(A) - expr == 0
+
+def test_w_diff_dcm2():
+    q1, q2, q3 = dynamicsymbols('q1:4')
+    N = ReferenceFrame('N')
+    A = N.orientnew('A', 'axis', [q1, N.x])
+    B = A.orientnew('B', 'axis', [q2, A.y])
+    C = B.orientnew('C', 'axis', [q3, B.z])
+
+    DCM = C.dcm(N).T
+    D = N.orientnew('D', 'DCM', DCM)
+
+    # Frames D and C are the same ReferenceFrame,
+    # since they have equal DCM respect to frame N.
+    # Therefore, D and C should have same angle velocity in N.
+    assert D.dcm(N) == C.dcm(N) == Matrix([
+        [cos(q2)*cos(q3), sin(q1)*sin(q2)*cos(q3) +
+        sin(q3)*cos(q1), sin(q1)*sin(q3) -
+        sin(q2)*cos(q1)*cos(q3)], [-sin(q3)*cos(q2),
+        -sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3),
+        sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)],
+        [sin(q2), -sin(q1)*cos(q2), cos(q1)*cos(q2)]])
+    assert (D.ang_vel_in(N) - C.ang_vel_in(N)).express(N).simplify() == 0
+
+def test_orientnew_respects_parent_class():
+    class MyReferenceFrame(ReferenceFrame):
+        pass
+    B = MyReferenceFrame('B')
+    C = B.orientnew('C', 'Axis', [0, B.x])
+    assert isinstance(C, MyReferenceFrame)
+
+
+def test_orientnew_respects_input_indices():
+    N = ReferenceFrame('N')
+    q1 = dynamicsymbols('q1')
+    A = N.orientnew('a', 'Axis', [q1, N.z])
+    #modify default indices:
+    minds = [x+'1' for x in N.indices]
+    B = N.orientnew('b', 'Axis', [q1, N.z], indices=minds)
+
+    assert N.indices == A.indices
+    assert B.indices == minds
+
+def test_orientnew_respects_input_latexs():
+    N = ReferenceFrame('N')
+    q1 = dynamicsymbols('q1')
+    A = N.orientnew('a', 'Axis', [q1, N.z])
+
+    #build default and alternate latex_vecs:
+    def_latex_vecs = [(r"\mathbf{\hat{%s}_%s}" % (A.name.lower(),
+                      A.indices[0])), (r"\mathbf{\hat{%s}_%s}" %
+                      (A.name.lower(), A.indices[1])),
+                      (r"\mathbf{\hat{%s}_%s}" % (A.name.lower(),
+                      A.indices[2]))]
+
+    name = 'b'
+    indices = [x+'1' for x in N.indices]
+    new_latex_vecs = [(r"\mathbf{\hat{%s}_{%s}}" % (name.lower(),
+                      indices[0])), (r"\mathbf{\hat{%s}_{%s}}" %
+                      (name.lower(), indices[1])),
+                      (r"\mathbf{\hat{%s}_{%s}}" % (name.lower(),
+                      indices[2]))]
+
+    B = N.orientnew(name, 'Axis', [q1, N.z], latexs=new_latex_vecs)
+
+    assert A.latex_vecs == def_latex_vecs
+    assert B.latex_vecs == new_latex_vecs
+    assert B.indices != indices
+
+def test_orientnew_respects_input_variables():
+    N = ReferenceFrame('N')
+    q1 = dynamicsymbols('q1')
+    A = N.orientnew('a', 'Axis', [q1, N.z])
+
+    #build non-standard variable names
+    name = 'b'
+    new_variables = ['notb_'+x+'1' for x in N.indices]
+    B = N.orientnew(name, 'Axis', [q1, N.z], variables=new_variables)
+
+    for j,var in enumerate(A.varlist):
+        assert var.name == A.name + '_' + A.indices[j]
+
+    for j,var in enumerate(B.varlist):
+        assert var.name == new_variables[j]
+
+def test_issue_10348():
+    u = dynamicsymbols('u:3')
+    I = ReferenceFrame('I')
+    I.orientnew('A', 'space', u, 'XYZ')
+
+
+def test_issue_11503():
+    A = ReferenceFrame("A")
+    A.orientnew("B", "Axis", [35, A.y])
+    C = ReferenceFrame("C")
+    A.orient(C, "Axis", [70, C.z])
+
+
+def test_partial_velocity():
+
+    N = ReferenceFrame('N')
+    A = ReferenceFrame('A')
+
+    u1, u2 = dynamicsymbols('u1, u2')
+
+    A.set_ang_vel(N, u1 * A.x + u2 * N.y)
+
+    assert N.partial_velocity(A, u1) == -A.x
+    assert N.partial_velocity(A, u1, u2) == (-A.x, -N.y)
+
+    assert A.partial_velocity(N, u1) == A.x
+    assert A.partial_velocity(N, u1, u2) == (A.x, N.y)
+
+    assert N.partial_velocity(N, u1) == 0
+    assert A.partial_velocity(A, u1) == 0
+
+
+def test_issue_11498():
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+
+    # Identity transformation
+    A.orient(B, 'DCM', eye(3))
+    assert A.dcm(B) == Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+    assert B.dcm(A) == Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+
+    # x -> y
+    # y -> -z
+    # z -> -x
+    A.orient(B, 'DCM', Matrix([[0, 1, 0], [0, 0, -1], [-1, 0, 0]]))
+    assert B.dcm(A) == Matrix([[0, 1, 0], [0, 0, -1], [-1, 0, 0]])
+    assert A.dcm(B) == Matrix([[0, 0, -1], [1, 0, 0], [0, -1, 0]])
+    assert B.dcm(A).T == A.dcm(B)
+
+
+def test_reference_frame():
+    raises(TypeError, lambda: ReferenceFrame(0))
+    raises(TypeError, lambda: ReferenceFrame('N', 0))
+    raises(ValueError, lambda: ReferenceFrame('N', [0, 1]))
+    raises(TypeError, lambda: ReferenceFrame('N', [0, 1, 2]))
+    raises(TypeError, lambda: ReferenceFrame('N', ['a', 'b', 'c'], 0))
+    raises(ValueError, lambda: ReferenceFrame('N', ['a', 'b', 'c'], [0, 1]))
+    raises(TypeError, lambda: ReferenceFrame('N', ['a', 'b', 'c'], [0, 1, 2]))
+    raises(TypeError, lambda: ReferenceFrame('N', ['a', 'b', 'c'],
+                                                 ['a', 'b', 'c'], 0))
+    raises(ValueError, lambda: ReferenceFrame('N', ['a', 'b', 'c'],
+                                              ['a', 'b', 'c'], [0, 1]))
+    raises(TypeError, lambda: ReferenceFrame('N', ['a', 'b', 'c'],
+                                             ['a', 'b', 'c'], [0, 1, 2]))
+    N = ReferenceFrame('N')
+    assert N[0] == CoordinateSym('N_x', N, 0)
+    assert N[1] == CoordinateSym('N_y', N, 1)
+    assert N[2] == CoordinateSym('N_z', N, 2)
+    raises(ValueError, lambda: N[3])
+    N = ReferenceFrame('N', ['a', 'b', 'c'])
+    assert N['a'] == N.x
+    assert N['b'] == N.y
+    assert N['c'] == N.z
+    raises(ValueError, lambda: N['d'])
+    assert str(N) == 'N'
+
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    q0, q1, q2, q3 = symbols('q0 q1 q2 q3')
+    raises(TypeError, lambda: A.orient(B, 'DCM', 0))
+    raises(TypeError, lambda: B.orient(N, 'Space', [q1, q2, q3], '222'))
+    raises(TypeError, lambda: B.orient(N, 'Axis', [q1, N.x + 2 * N.y], '222'))
+    raises(TypeError, lambda: B.orient(N, 'Axis', q1))
+    raises(IndexError, lambda: B.orient(N, 'Axis', [q1]))
+    raises(TypeError, lambda: B.orient(N, 'Quaternion', [q0, q1, q2, q3], '222'))
+    raises(TypeError, lambda: B.orient(N, 'Quaternion', q0))
+    raises(TypeError, lambda: B.orient(N, 'Quaternion', [q0, q1, q2]))
+    raises(NotImplementedError, lambda: B.orient(N, 'Foo', [q0, q1, q2]))
+    raises(TypeError, lambda: B.orient(N, 'Body', [q1, q2], '232'))
+    raises(TypeError, lambda: B.orient(N, 'Space', [q1, q2], '232'))
+
+    N.set_ang_acc(B, 0)
+    assert N.ang_acc_in(B) == Vector(0)
+    N.set_ang_vel(B, 0)
+    assert N.ang_vel_in(B) == Vector(0)
+
+
+def test_check_frame():
+    raises(VectorTypeError, lambda: _check_frame(0))
+
+
+def test_dcm_diff_16824():
+    # NOTE : This is a regression test for the bug introduced in PR 14758,
+    # identified in 16824, and solved by PR 16828.
+
+    # This is the solution to Problem 2.2 on page 264 in Kane & Lenvinson's
+    # 1985 book.
+
+    q1, q2, q3 = dynamicsymbols('q1:4')
+
+    s1 = sin(q1)
+    c1 = cos(q1)
+    s2 = sin(q2)
+    c2 = cos(q2)
+    s3 = sin(q3)
+    c3 = cos(q3)
+
+    dcm = Matrix([[c2*c3, s1*s2*c3 - s3*c1, c1*s2*c3 + s3*s1],
+                  [c2*s3, s1*s2*s3 + c3*c1, c1*s2*s3 - c3*s1],
+                  [-s2,   s1*c2,            c1*c2]])
+
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    B.orient(A, 'DCM', dcm)
+
+    AwB = B.ang_vel_in(A)
+
+    alpha2 = s3*c2*q1.diff() + c3*q2.diff()
+    beta2 = s1*c2*q3.diff() + c1*q2.diff()
+
+    assert simplify(AwB.dot(A.y) - alpha2) == 0
+    assert simplify(AwB.dot(B.y) - beta2) == 0
+
+def test_orient_explicit():
+    cxx, cyy, czz = dynamicsymbols('c_{xx}, c_{yy}, c_{zz}')
+    cxy, cxz, cyx = dynamicsymbols('c_{xy}, c_{xz}, c_{yx}')
+    cyz, czx, czy = dynamicsymbols('c_{yz}, c_{zx}, c_{zy}')
+    dcxx, dcyy, dczz = dynamicsymbols('c_{xx}, c_{yy}, c_{zz}', 1)
+    dcxy, dcxz, dcyx = dynamicsymbols('c_{xy}, c_{xz}, c_{yx}', 1)
+    dcyz, dczx, dczy = dynamicsymbols('c_{yz}, c_{zx}, c_{zy}', 1)
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    B_C_A = Matrix([[cxx, cxy, cxz],
+                    [cyx, cyy, cyz],
+                    [czx, czy, czz]])
+    B_w_A = ((cyx*dczx + cyy*dczy + cyz*dczz)*B.x +
+            (czx*dcxx + czy*dcxy + czz*dcxz)*B.y +
+            (cxx*dcyx + cxy*dcyy + cxz*dcyz)*B.z)
+    A.orient_explicit(B, B_C_A)
+    assert B.dcm(A) == B_C_A
+    assert A.ang_vel_in(B) == B_w_A
+    assert B.ang_vel_in(A) == -B_w_A
+
+def test_orient_dcm():
+    cxx, cyy, czz = dynamicsymbols('c_{xx}, c_{yy}, c_{zz}')
+    cxy, cxz, cyx = dynamicsymbols('c_{xy}, c_{xz}, c_{yx}')
+    cyz, czx, czy = dynamicsymbols('c_{yz}, c_{zx}, c_{zy}')
+    B_C_A = Matrix([[cxx, cxy, cxz],
+                    [cyx, cyy, cyz],
+                    [czx, czy, czz]])
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    B.orient_dcm(A, B_C_A)
+    assert B.dcm(A) == Matrix([[cxx, cxy, cxz],
+                               [cyx, cyy, cyz],
+                               [czx, czy, czz]])
+
+def test_orient_axis():
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    A.orient_axis(B,-B.x, 1)
+    A1 = A.dcm(B)
+    A.orient_axis(B, B.x, -1)
+    A2 = A.dcm(B)
+    A.orient_axis(B, 1, -B.x)
+    A3 = A.dcm(B)
+    assert A1 == A2
+    assert A2 == A3
+    raises(TypeError, lambda: A.orient_axis(B, 1, 1))
+
+def test_orient_body():
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    B.orient_body_fixed(A, (1,1,0), 'XYX')
+    assert B.dcm(A) == Matrix([[cos(1), sin(1)**2, -sin(1)*cos(1)], [0, cos(1), sin(1)], [sin(1), -sin(1)*cos(1), cos(1)**2]])
+
+
+def test_orient_body_advanced():
+    q1, q2, q3 = dynamicsymbols('q1:4')
+    c1, c2, c3 = symbols('c1:4')
+    u1, u2, u3 = dynamicsymbols('q1:4', 1)
+
+    # Test with everything as dynamicsymbols
+    A, B = ReferenceFrame('A'), ReferenceFrame('B')
+    B.orient_body_fixed(A, (q1, q2, q3), 'zxy')
+    assert A.dcm(B) == Matrix([
+        [-sin(q1) * sin(q2) * sin(q3) + cos(q1) * cos(q3), -sin(q1) * cos(q2),
+         sin(q1) * sin(q2) * cos(q3) + sin(q3) * cos(q1)],
+        [sin(q1) * cos(q3) + sin(q2) * sin(q3) * cos(q1), cos(q1) * cos(q2),
+         sin(q1) * sin(q3) - sin(q2) * cos(q1) * cos(q3)],
+        [-sin(q3) * cos(q2), sin(q2), cos(q2) * cos(q3)]])
+    assert B.ang_vel_in(A).to_matrix(B) == Matrix([
+        [-sin(q3) * cos(q2) * u1 + cos(q3) * u2],
+        [sin(q2) * u1 + u3],
+        [sin(q3) * u2 + cos(q2) * cos(q3) * u1]])
+
+    # Test with constant symbol
+    A, B = ReferenceFrame('A'), ReferenceFrame('B')
+    B.orient_body_fixed(A, (q1, c2, q3), 131)
+    assert A.dcm(B) == Matrix([
+        [cos(c2), -sin(c2) * cos(q3), sin(c2) * sin(q3)],
+        [sin(c2) * cos(q1), -sin(q1) * sin(q3) + cos(c2) * cos(q1) * cos(q3),
+         -sin(q1) * cos(q3) - sin(q3) * cos(c2) * cos(q1)],
+        [sin(c2) * sin(q1), sin(q1) * cos(c2) * cos(q3) + sin(q3) * cos(q1),
+         -sin(q1) * sin(q3) * cos(c2) + cos(q1) * cos(q3)]])
+    assert B.ang_vel_in(A).to_matrix(B) == Matrix([
+        [cos(c2) * u1 + u3],
+        [-sin(c2) * cos(q3) * u1],
+        [sin(c2) * sin(q3) * u1]])
+
+    # Test all symbols not time dependent
+    A, B = ReferenceFrame('A'), ReferenceFrame('B')
+    B.orient_body_fixed(A, (c1, c2, c3), 123)
+    assert B.ang_vel_in(A) == Vector(0)
+
+
+def test_orient_space_advanced():
+    # space fixed is in the end like body fixed only in opposite order
+    q1, q2, q3 = dynamicsymbols('q1:4')
+    c1, c2, c3 = symbols('c1:4')
+    u1, u2, u3 = dynamicsymbols('q1:4', 1)
+
+    # Test with everything as dynamicsymbols
+    A, B = ReferenceFrame('A'), ReferenceFrame('B')
+    B.orient_space_fixed(A, (q3, q2, q1), 'yxz')
+    assert A.dcm(B) == Matrix([
+        [-sin(q1) * sin(q2) * sin(q3) + cos(q1) * cos(q3), -sin(q1) * cos(q2),
+         sin(q1) * sin(q2) * cos(q3) + sin(q3) * cos(q1)],
+        [sin(q1) * cos(q3) + sin(q2) * sin(q3) * cos(q1), cos(q1) * cos(q2),
+         sin(q1) * sin(q3) - sin(q2) * cos(q1) * cos(q3)],
+        [-sin(q3) * cos(q2), sin(q2), cos(q2) * cos(q3)]])
+    assert B.ang_vel_in(A).to_matrix(B) == Matrix([
+        [-sin(q3) * cos(q2) * u1 + cos(q3) * u2],
+        [sin(q2) * u1 + u3],
+        [sin(q3) * u2 + cos(q2) * cos(q3) * u1]])
+
+    # Test with constant symbol
+    A, B = ReferenceFrame('A'), ReferenceFrame('B')
+    B.orient_space_fixed(A, (q3, c2, q1), 131)
+    assert A.dcm(B) == Matrix([
+        [cos(c2), -sin(c2) * cos(q3), sin(c2) * sin(q3)],
+        [sin(c2) * cos(q1), -sin(q1) * sin(q3) + cos(c2) * cos(q1) * cos(q3),
+         -sin(q1) * cos(q3) - sin(q3) * cos(c2) * cos(q1)],
+        [sin(c2) * sin(q1), sin(q1) * cos(c2) * cos(q3) + sin(q3) * cos(q1),
+         -sin(q1) * sin(q3) * cos(c2) + cos(q1) * cos(q3)]])
+    assert B.ang_vel_in(A).to_matrix(B) == Matrix([
+        [cos(c2) * u1 + u3],
+        [-sin(c2) * cos(q3) * u1],
+        [sin(c2) * sin(q3) * u1]])
+
+    # Test all symbols not time dependent
+    A, B = ReferenceFrame('A'), ReferenceFrame('B')
+    B.orient_space_fixed(A, (c1, c2, c3), 123)
+    assert B.ang_vel_in(A) == Vector(0)
+
+
+def test_orient_body_simple_ang_vel():
+    """This test ensures that the simplest form of that linear system solution
+    is returned, thus the == for the expression comparison."""
+
+    psi, theta, phi = dynamicsymbols('psi, theta, varphi')
+    t = dynamicsymbols._t
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    B.orient_body_fixed(A, (psi, theta, phi), 'ZXZ')
+    A_w_B = B.ang_vel_in(A)
+    assert A_w_B.args[0][1] == B
+    assert A_w_B.args[0][0][0] == (sin(theta)*sin(phi)*psi.diff(t) +
+                                   cos(phi)*theta.diff(t))
+    assert A_w_B.args[0][0][1] == (sin(theta)*cos(phi)*psi.diff(t) -
+                                   sin(phi)*theta.diff(t))
+    assert A_w_B.args[0][0][2] == cos(theta)*psi.diff(t) + phi.diff(t)
+
+
+def test_orient_space():
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    B.orient_space_fixed(A, (0,0,0), '123')
+    assert B.dcm(A) == Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+
+def test_orient_quaternion():
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    B.orient_quaternion(A, (0,0,0,0))
+    assert B.dcm(A) == Matrix([[0, 0, 0], [0, 0, 0], [0, 0, 0]])
+
+def test_looped_frame_warning():
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    C = ReferenceFrame('C')
+
+    a, b, c = symbols('a b c')
+    B.orient_axis(A, A.x, a)
+    C.orient_axis(B, B.x, b)
+
+    with warnings.catch_warnings(record = True) as w:
+        warnings.simplefilter("always")
+        A.orient_axis(C, C.x, c)
+        assert issubclass(w[-1].category, UserWarning)
+        assert 'Loops are defined among the orientation of frames. ' + \
+            'This is likely not desired and may cause errors in your calculations.' in str(w[-1].message)
+
+def test_frame_dict():
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    C = ReferenceFrame('C')
+
+    a, b, c = symbols('a b c')
+
+    B.orient_axis(A, A.x, a)
+    assert A._dcm_dict == {B: Matrix([[1, 0, 0],[0, cos(a), -sin(a)],[0, sin(a),  cos(a)]])}
+    assert B._dcm_dict == {A: Matrix([[1, 0, 0],[0,  cos(a), sin(a)],[0, -sin(a), cos(a)]])}
+    assert C._dcm_dict == {}
+
+    B.orient_axis(C, C.x, b)
+    # Previous relation is not wiped
+    assert A._dcm_dict == {B: Matrix([[1, 0, 0],[0, cos(a), -sin(a)],[0, sin(a),  cos(a)]])}
+    assert B._dcm_dict == {A: Matrix([[1, 0, 0],[0,  cos(a), sin(a)],[0, -sin(a), cos(a)]]), \
+        C: Matrix([[1, 0, 0],[0,  cos(b), sin(b)],[0, -sin(b), cos(b)]])}
+    assert C._dcm_dict == {B: Matrix([[1, 0, 0],[0, cos(b), -sin(b)],[0, sin(b),  cos(b)]])}
+
+    A.orient_axis(B, B.x, c)
+    # Previous relation is updated
+    assert B._dcm_dict == {C: Matrix([[1, 0, 0],[0,  cos(b), sin(b)],[0, -sin(b), cos(b)]]),\
+        A: Matrix([[1, 0, 0],[0, cos(c), -sin(c)],[0, sin(c),  cos(c)]])}
+    assert A._dcm_dict == {B: Matrix([[1, 0, 0],[0,  cos(c), sin(c)],[0, -sin(c), cos(c)]])}
+    assert C._dcm_dict == {B: Matrix([[1, 0, 0],[0, cos(b), -sin(b)],[0, sin(b),  cos(b)]])}
+
+def test_dcm_cache_dict():
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    C = ReferenceFrame('C')
+    D = ReferenceFrame('D')
+
+    a, b, c = symbols('a b c')
+
+    B.orient_axis(A, A.x, a)
+    C.orient_axis(B, B.x, b)
+    D.orient_axis(C, C.x, c)
+
+    assert D._dcm_dict == {C: Matrix([[1, 0, 0],[0,  cos(c), sin(c)],[0, -sin(c), cos(c)]])}
+    assert C._dcm_dict == {B: Matrix([[1, 0, 0],[0,  cos(b), sin(b)],[0, -sin(b), cos(b)]]), \
+        D: Matrix([[1, 0, 0],[0, cos(c), -sin(c)],[0, sin(c),  cos(c)]])}
+    assert B._dcm_dict == {A: Matrix([[1, 0, 0],[0,  cos(a), sin(a)],[0, -sin(a), cos(a)]]), \
+        C: Matrix([[1, 0, 0],[0, cos(b), -sin(b)],[0, sin(b),  cos(b)]])}
+    assert A._dcm_dict == {B: Matrix([[1, 0, 0],[0, cos(a), -sin(a)],[0, sin(a),  cos(a)]])}
+
+    assert D._dcm_dict == D._dcm_cache
+
+    D.dcm(A) # Check calculated dcm relation is stored in _dcm_cache and not in _dcm_dict
+    assert list(A._dcm_cache.keys()) == [A, B, D]
+    assert list(D._dcm_cache.keys()) == [C, A]
+    assert list(A._dcm_dict.keys()) == [B]
+    assert list(D._dcm_dict.keys()) == [C]
+    assert A._dcm_dict != A._dcm_cache
+
+    A.orient_axis(B, B.x, b) # _dcm_cache of A is wiped out and new relation is stored.
+    assert A._dcm_dict == {B: Matrix([[1, 0, 0],[0,  cos(b), sin(b)],[0, -sin(b), cos(b)]])}
+    assert A._dcm_dict == A._dcm_cache
+    assert B._dcm_dict == {C: Matrix([[1, 0, 0],[0, cos(b), -sin(b)],[0, sin(b),  cos(b)]]), \
+        A: Matrix([[1, 0, 0],[0, cos(b), -sin(b)],[0, sin(b),  cos(b)]])}
+
+def test_xx_dyad():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.xx == Vector.outer(N.x, N.x)
+    assert F.xx == Vector.outer(F.x, F.x)
+
+def test_xy_dyad():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.xy == Vector.outer(N.x, N.y)
+    assert F.xy == Vector.outer(F.x, F.y)
+
+def test_xz_dyad():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.xz == Vector.outer(N.x, N.z)
+    assert F.xz == Vector.outer(F.x, F.z)
+
+def test_yx_dyad():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.yx == Vector.outer(N.y, N.x)
+    assert F.yx == Vector.outer(F.y, F.x)
+
+def test_yy_dyad():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.yy == Vector.outer(N.y, N.y)
+    assert F.yy == Vector.outer(F.y, F.y)
+
+def test_yz_dyad():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.yz == Vector.outer(N.y, N.z)
+    assert F.yz == Vector.outer(F.y, F.z)
+
+def test_zx_dyad():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.zx == Vector.outer(N.z, N.x)
+    assert F.zx == Vector.outer(F.z, F.x)
+
+def test_zy_dyad():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.zy == Vector.outer(N.z, N.y)
+    assert F.zy == Vector.outer(F.z, F.y)
+
+def test_zz_dyad():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.zz == Vector.outer(N.z, N.z)
+    assert F.zz == Vector.outer(F.z, F.z)
+
+def test_unit_dyadic():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.u == N.xx + N.yy + N.zz
+    assert F.u == F.xx + F.yy + F.zz
+
+
+def test_pickle_frame():
+    N = ReferenceFrame('N')
+    A = ReferenceFrame('A')
+    A.orient_axis(N, N.x, 1)
+    A_C_N = A.dcm(N)
+    N1 = pickle.loads(pickle.dumps(N))
+    A1 = tuple(N1._dcm_dict.keys())[0]
+    assert A1.dcm(N1) == A_C_N

venv/lib/python3.11/site-packages/sympy/physics/vector/tests/test_functions.py

@@ -0,0 +1,509 @@
+from sympy.core.numbers import pi
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.integrals.integrals import Integral
+from sympy.physics.vector import Dyadic, Point, ReferenceFrame, Vector
+from sympy.physics.vector.functions import (cross, dot, express,
+                                            time_derivative,
+                                            kinematic_equations, outer,
+                                            partial_velocity,
+                                            get_motion_params, dynamicsymbols)
+from sympy.simplify import trigsimp
+from sympy.testing.pytest import raises
+
+q1, q2, q3, q4, q5 = symbols('q1 q2 q3 q4 q5')
+N = ReferenceFrame('N')
+A = N.orientnew('A', 'Axis', [q1, N.z])
+B = A.orientnew('B', 'Axis', [q2, A.x])
+C = B.orientnew('C', 'Axis', [q3, B.y])
+
+
+def test_dot():
+    assert dot(A.x, A.x) == 1
+    assert dot(A.x, A.y) == 0
+    assert dot(A.x, A.z) == 0
+
+    assert dot(A.y, A.x) == 0
+    assert dot(A.y, A.y) == 1
+    assert dot(A.y, A.z) == 0
+
+    assert dot(A.z, A.x) == 0
+    assert dot(A.z, A.y) == 0
+    assert dot(A.z, A.z) == 1
+
+
+def test_dot_different_frames():
+    assert dot(N.x, A.x) == cos(q1)
+    assert dot(N.x, A.y) == -sin(q1)
+    assert dot(N.x, A.z) == 0
+    assert dot(N.y, A.x) == sin(q1)
+    assert dot(N.y, A.y) == cos(q1)
+    assert dot(N.y, A.z) == 0
+    assert dot(N.z, A.x) == 0
+    assert dot(N.z, A.y) == 0
+    assert dot(N.z, A.z) == 1
+
+    assert trigsimp(dot(N.x, A.x + A.y)) == sqrt(2)*cos(q1 + pi/4)
+    assert trigsimp(dot(N.x, A.x + A.y)) == trigsimp(dot(A.x + A.y, N.x))
+
+    assert dot(A.x, C.x) == cos(q3)
+    assert dot(A.x, C.y) == 0
+    assert dot(A.x, C.z) == sin(q3)
+    assert dot(A.y, C.x) == sin(q2)*sin(q3)
+    assert dot(A.y, C.y) == cos(q2)
+    assert dot(A.y, C.z) == -sin(q2)*cos(q3)
+    assert dot(A.z, C.x) == -cos(q2)*sin(q3)
+    assert dot(A.z, C.y) == sin(q2)
+    assert dot(A.z, C.z) == cos(q2)*cos(q3)
+
+
+def test_cross():
+    assert cross(A.x, A.x) == 0
+    assert cross(A.x, A.y) == A.z
+    assert cross(A.x, A.z) == -A.y
+
+    assert cross(A.y, A.x) == -A.z
+    assert cross(A.y, A.y) == 0
+    assert cross(A.y, A.z) == A.x
+
+    assert cross(A.z, A.x) == A.y
+    assert cross(A.z, A.y) == -A.x
+    assert cross(A.z, A.z) == 0
+
+
+def test_cross_different_frames():
+    assert cross(N.x, A.x) == sin(q1)*A.z
+    assert cross(N.x, A.y) == cos(q1)*A.z
+    assert cross(N.x, A.z) == -sin(q1)*A.x - cos(q1)*A.y
+    assert cross(N.y, A.x) == -cos(q1)*A.z
+    assert cross(N.y, A.y) == sin(q1)*A.z
+    assert cross(N.y, A.z) == cos(q1)*A.x - sin(q1)*A.y
+    assert cross(N.z, A.x) == A.y
+    assert cross(N.z, A.y) == -A.x
+    assert cross(N.z, A.z) == 0
+
+    assert cross(N.x, A.x) == sin(q1)*A.z
+    assert cross(N.x, A.y) == cos(q1)*A.z
+    assert cross(N.x, A.x + A.y) == sin(q1)*A.z + cos(q1)*A.z
+    assert cross(A.x + A.y, N.x) == -sin(q1)*A.z - cos(q1)*A.z
+
+    assert cross(A.x, C.x) == sin(q3)*C.y
+    assert cross(A.x, C.y) == -sin(q3)*C.x + cos(q3)*C.z
+    assert cross(A.x, C.z) == -cos(q3)*C.y
+    assert cross(C.x, A.x) == -sin(q3)*C.y
+    assert cross(C.y, A.x).express(C).simplify() == sin(q3)*C.x - cos(q3)*C.z
+    assert cross(C.z, A.x) == cos(q3)*C.y
+
+def test_operator_match():
+    """Test that the output of dot, cross, outer functions match
+    operator behavior.
+    """
+    A = ReferenceFrame('A')
+    v = A.x + A.y
+    d = v | v
+    zerov = Vector(0)
+    zerod = Dyadic(0)
+
+    # dot products
+    assert d & d == dot(d, d)
+    assert d & zerod == dot(d, zerod)
+    assert zerod & d == dot(zerod, d)
+    assert d & v == dot(d, v)
+    assert v & d == dot(v, d)
+    assert d & zerov == dot(d, zerov)
+    assert zerov & d == dot(zerov, d)
+    raises(TypeError, lambda: dot(d, S.Zero))
+    raises(TypeError, lambda: dot(S.Zero, d))
+    raises(TypeError, lambda: dot(d, 0))
+    raises(TypeError, lambda: dot(0, d))
+    assert v & v == dot(v, v)
+    assert v & zerov == dot(v, zerov)
+    assert zerov & v == dot(zerov, v)
+    raises(TypeError, lambda: dot(v, S.Zero))
+    raises(TypeError, lambda: dot(S.Zero, v))
+    raises(TypeError, lambda: dot(v, 0))
+    raises(TypeError, lambda: dot(0, v))
+
+    # cross products
+    raises(TypeError, lambda: cross(d, d))
+    raises(TypeError, lambda: cross(d, zerod))
+    raises(TypeError, lambda: cross(zerod, d))
+    assert d ^ v == cross(d, v)
+    assert v ^ d == cross(v, d)
+    assert d ^ zerov == cross(d, zerov)
+    assert zerov ^ d == cross(zerov, d)
+    assert zerov ^ d == cross(zerov, d)
+    raises(TypeError, lambda: cross(d, S.Zero))
+    raises(TypeError, lambda: cross(S.Zero, d))
+    raises(TypeError, lambda: cross(d, 0))
+    raises(TypeError, lambda: cross(0, d))
+    assert v ^ v == cross(v, v)
+    assert v ^ zerov == cross(v, zerov)
+    assert zerov ^ v == cross(zerov, v)
+    raises(TypeError, lambda: cross(v, S.Zero))
+    raises(TypeError, lambda: cross(S.Zero, v))
+    raises(TypeError, lambda: cross(v, 0))
+    raises(TypeError, lambda: cross(0, v))
+
+    # outer products
+    raises(TypeError, lambda: outer(d, d))
+    raises(TypeError, lambda: outer(d, zerod))
+    raises(TypeError, lambda: outer(zerod, d))
+    raises(TypeError, lambda: outer(d, v))
+    raises(TypeError, lambda: outer(v, d))
+    raises(TypeError, lambda: outer(d, zerov))
+    raises(TypeError, lambda: outer(zerov, d))
+    raises(TypeError, lambda: outer(zerov, d))
+    raises(TypeError, lambda: outer(d, S.Zero))
+    raises(TypeError, lambda: outer(S.Zero, d))
+    raises(TypeError, lambda: outer(d, 0))
+    raises(TypeError, lambda: outer(0, d))
+    assert v | v == outer(v, v)
+    assert v | zerov == outer(v, zerov)
+    assert zerov | v == outer(zerov, v)
+    raises(TypeError, lambda: outer(v, S.Zero))
+    raises(TypeError, lambda: outer(S.Zero, v))
+    raises(TypeError, lambda: outer(v, 0))
+    raises(TypeError, lambda: outer(0, v))
+
+
+def test_express():
+    assert express(Vector(0), N) == Vector(0)
+    assert express(S.Zero, N) is S.Zero
+    assert express(A.x, C) == cos(q3)*C.x + sin(q3)*C.z
+    assert express(A.y, C) == sin(q2)*sin(q3)*C.x + cos(q2)*C.y - \
+        sin(q2)*cos(q3)*C.z
+    assert express(A.z, C) == -sin(q3)*cos(q2)*C.x + sin(q2)*C.y + \
+        cos(q2)*cos(q3)*C.z
+    assert express(A.x, N) == cos(q1)*N.x + sin(q1)*N.y
+    assert express(A.y, N) == -sin(q1)*N.x + cos(q1)*N.y
+    assert express(A.z, N) == N.z
+    assert express(A.x, A) == A.x
+    assert express(A.y, A) == A.y
+    assert express(A.z, A) == A.z
+    assert express(A.x, B) == B.x
+    assert express(A.y, B) == cos(q2)*B.y - sin(q2)*B.z
+    assert express(A.z, B) == sin(q2)*B.y + cos(q2)*B.z
+    assert express(A.x, C) == cos(q3)*C.x + sin(q3)*C.z
+    assert express(A.y, C) == sin(q2)*sin(q3)*C.x + cos(q2)*C.y - \
+        sin(q2)*cos(q3)*C.z
+    assert express(A.z, C) == -sin(q3)*cos(q2)*C.x + sin(q2)*C.y + \
+        cos(q2)*cos(q3)*C.z
+    # Check to make sure UnitVectors get converted properly
+    assert express(N.x, N) == N.x
+    assert express(N.y, N) == N.y
+    assert express(N.z, N) == N.z
+    assert express(N.x, A) == (cos(q1)*A.x - sin(q1)*A.y)
+    assert express(N.y, A) == (sin(q1)*A.x + cos(q1)*A.y)
+    assert express(N.z, A) == A.z
+    assert express(N.x, B) == (cos(q1)*B.x - sin(q1)*cos(q2)*B.y +
+            sin(q1)*sin(q2)*B.z)
+    assert express(N.y, B) == (sin(q1)*B.x + cos(q1)*cos(q2)*B.y -
+            sin(q2)*cos(q1)*B.z)
+    assert express(N.z, B) == (sin(q2)*B.y + cos(q2)*B.z)
+    assert express(N.x, C) == (
+        (cos(q1)*cos(q3) - sin(q1)*sin(q2)*sin(q3))*C.x -
+        sin(q1)*cos(q2)*C.y +
+        (sin(q3)*cos(q1) + sin(q1)*sin(q2)*cos(q3))*C.z)
+    assert express(N.y, C) == (
+        (sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1))*C.x +
+        cos(q1)*cos(q2)*C.y +
+        (sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3))*C.z)
+    assert express(N.z, C) == (-sin(q3)*cos(q2)*C.x + sin(q2)*C.y +
+            cos(q2)*cos(q3)*C.z)
+
+    assert express(A.x, N) == (cos(q1)*N.x + sin(q1)*N.y)
+    assert express(A.y, N) == (-sin(q1)*N.x + cos(q1)*N.y)
+    assert express(A.z, N) == N.z
+    assert express(A.x, A) == A.x
+    assert express(A.y, A) == A.y
+    assert express(A.z, A) == A.z
+    assert express(A.x, B) == B.x
+    assert express(A.y, B) == (cos(q2)*B.y - sin(q2)*B.z)
+    assert express(A.z, B) == (sin(q2)*B.y + cos(q2)*B.z)
+    assert express(A.x, C) == (cos(q3)*C.x + sin(q3)*C.z)
+    assert express(A.y, C) == (sin(q2)*sin(q3)*C.x + cos(q2)*C.y -
+            sin(q2)*cos(q3)*C.z)
+    assert express(A.z, C) == (-sin(q3)*cos(q2)*C.x + sin(q2)*C.y +
+            cos(q2)*cos(q3)*C.z)
+
+    assert express(B.x, N) == (cos(q1)*N.x + sin(q1)*N.y)
+    assert express(B.y, N) == (-sin(q1)*cos(q2)*N.x +
+            cos(q1)*cos(q2)*N.y + sin(q2)*N.z)
+    assert express(B.z, N) == (sin(q1)*sin(q2)*N.x -
+            sin(q2)*cos(q1)*N.y + cos(q2)*N.z)
+    assert express(B.x, A) == A.x
+    assert express(B.y, A) == (cos(q2)*A.y + sin(q2)*A.z)
+    assert express(B.z, A) == (-sin(q2)*A.y + cos(q2)*A.z)
+    assert express(B.x, B) == B.x
+    assert express(B.y, B) == B.y
+    assert express(B.z, B) == B.z
+    assert express(B.x, C) == (cos(q3)*C.x + sin(q3)*C.z)
+    assert express(B.y, C) == C.y
+    assert express(B.z, C) == (-sin(q3)*C.x + cos(q3)*C.z)
+
+    assert express(C.x, N) == (
+        (cos(q1)*cos(q3) - sin(q1)*sin(q2)*sin(q3))*N.x +
+        (sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1))*N.y -
+        sin(q3)*cos(q2)*N.z)
+    assert express(C.y, N) == (
+        -sin(q1)*cos(q2)*N.x + cos(q1)*cos(q2)*N.y + sin(q2)*N.z)
+    assert express(C.z, N) == (
+        (sin(q3)*cos(q1) + sin(q1)*sin(q2)*cos(q3))*N.x +
+        (sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3))*N.y +
+        cos(q2)*cos(q3)*N.z)
+    assert express(C.x, A) == (cos(q3)*A.x + sin(q2)*sin(q3)*A.y -
+            sin(q3)*cos(q2)*A.z)
+    assert express(C.y, A) == (cos(q2)*A.y + sin(q2)*A.z)
+    assert express(C.z, A) == (sin(q3)*A.x - sin(q2)*cos(q3)*A.y +
+            cos(q2)*cos(q3)*A.z)
+    assert express(C.x, B) == (cos(q3)*B.x - sin(q3)*B.z)
+    assert express(C.y, B) == B.y
+    assert express(C.z, B) == (sin(q3)*B.x + cos(q3)*B.z)
+    assert express(C.x, C) == C.x
+    assert express(C.y, C) == C.y
+    assert express(C.z, C) == C.z == (C.z)
+
+    #  Check to make sure Vectors get converted back to UnitVectors
+    assert N.x == express((cos(q1)*A.x - sin(q1)*A.y), N).simplify()
+    assert N.y == express((sin(q1)*A.x + cos(q1)*A.y), N).simplify()
+    assert N.x == express((cos(q1)*B.x - sin(q1)*cos(q2)*B.y +
+            sin(q1)*sin(q2)*B.z), N).simplify()
+    assert N.y == express((sin(q1)*B.x + cos(q1)*cos(q2)*B.y -
+        sin(q2)*cos(q1)*B.z), N).simplify()
+    assert N.z == express((sin(q2)*B.y + cos(q2)*B.z), N).simplify()
+
+    """
+    These don't really test our code, they instead test the auto simplification
+    (or lack thereof) of SymPy.
+    assert N.x == express((
+            (cos(q1)*cos(q3)-sin(q1)*sin(q2)*sin(q3))*C.x -
+            sin(q1)*cos(q2)*C.y +
+            (sin(q3)*cos(q1)+sin(q1)*sin(q2)*cos(q3))*C.z), N)
+    assert N.y == express((
+            (sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1))*C.x +
+            cos(q1)*cos(q2)*C.y +
+            (sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3))*C.z), N)
+    assert N.z == express((-sin(q3)*cos(q2)*C.x + sin(q2)*C.y +
+            cos(q2)*cos(q3)*C.z), N)
+    """
+
+    assert A.x == express((cos(q1)*N.x + sin(q1)*N.y), A).simplify()
+    assert A.y == express((-sin(q1)*N.x + cos(q1)*N.y), A).simplify()
+
+    assert A.y == express((cos(q2)*B.y - sin(q2)*B.z), A).simplify()
+    assert A.z == express((sin(q2)*B.y + cos(q2)*B.z), A).simplify()
+
+    assert A.x == express((cos(q3)*C.x + sin(q3)*C.z), A).simplify()
+
+    # Tripsimp messes up here too.
+    #print express((sin(q2)*sin(q3)*C.x + cos(q2)*C.y -
+    #        sin(q2)*cos(q3)*C.z), A)
+    assert A.y == express((sin(q2)*sin(q3)*C.x + cos(q2)*C.y -
+            sin(q2)*cos(q3)*C.z), A).simplify()
+
+    assert A.z == express((-sin(q3)*cos(q2)*C.x + sin(q2)*C.y +
+            cos(q2)*cos(q3)*C.z), A).simplify()
+    assert B.x == express((cos(q1)*N.x + sin(q1)*N.y), B).simplify()
+    assert B.y == express((-sin(q1)*cos(q2)*N.x +
+            cos(q1)*cos(q2)*N.y + sin(q2)*N.z), B).simplify()
+
+    assert B.z == express((sin(q1)*sin(q2)*N.x -
+            sin(q2)*cos(q1)*N.y + cos(q2)*N.z), B).simplify()
+
+    assert B.y == express((cos(q2)*A.y + sin(q2)*A.z), B).simplify()
+    assert B.z == express((-sin(q2)*A.y + cos(q2)*A.z), B).simplify()
+    assert B.x == express((cos(q3)*C.x + sin(q3)*C.z), B).simplify()
+    assert B.z == express((-sin(q3)*C.x + cos(q3)*C.z), B).simplify()
+
+    """
+    assert C.x == express((
+            (cos(q1)*cos(q3)-sin(q1)*sin(q2)*sin(q3))*N.x +
+            (sin(q1)*cos(q3)+sin(q2)*sin(q3)*cos(q1))*N.y -
+                sin(q3)*cos(q2)*N.z), C)
+    assert C.y == express((
+            -sin(q1)*cos(q2)*N.x + cos(q1)*cos(q2)*N.y + sin(q2)*N.z), C)
+    assert C.z == express((
+            (sin(q3)*cos(q1)+sin(q1)*sin(q2)*cos(q3))*N.x +
+            (sin(q1)*sin(q3)-sin(q2)*cos(q1)*cos(q3))*N.y +
+            cos(q2)*cos(q3)*N.z), C)
+    """
+    assert C.x == express((cos(q3)*A.x + sin(q2)*sin(q3)*A.y -
+            sin(q3)*cos(q2)*A.z), C).simplify()
+    assert C.y == express((cos(q2)*A.y + sin(q2)*A.z), C).simplify()
+    assert C.z == express((sin(q3)*A.x - sin(q2)*cos(q3)*A.y +
+            cos(q2)*cos(q3)*A.z), C).simplify()
+    assert C.x == express((cos(q3)*B.x - sin(q3)*B.z), C).simplify()
+    assert C.z == express((sin(q3)*B.x + cos(q3)*B.z), C).simplify()
+
+
+def test_time_derivative():
+    #The use of time_derivative for calculations pertaining to scalar
+    #fields has been tested in test_coordinate_vars in test_essential.py
+    A = ReferenceFrame('A')
+    q = dynamicsymbols('q')
+    qd = dynamicsymbols('q', 1)
+    B = A.orientnew('B', 'Axis', [q, A.z])
+    d = A.x | A.x
+    assert time_derivative(d, B) == (-qd) * (A.y | A.x) + \
+           (-qd) * (A.x | A.y)
+    d1 = A.x | B.y
+    assert time_derivative(d1, A) == - qd*(A.x|B.x)
+    assert time_derivative(d1, B) == - qd*(A.y|B.y)
+    d2 = A.x | B.x
+    assert time_derivative(d2, A) == qd*(A.x|B.y)
+    assert time_derivative(d2, B) == - qd*(A.y|B.x)
+    d3 = A.x | B.z
+    assert time_derivative(d3, A) == 0
+    assert time_derivative(d3, B) == - qd*(A.y|B.z)
+    q1, q2, q3, q4 = dynamicsymbols('q1 q2 q3 q4')
+    q1d, q2d, q3d, q4d = dynamicsymbols('q1 q2 q3 q4', 1)
+    q1dd, q2dd, q3dd, q4dd = dynamicsymbols('q1 q2 q3 q4', 2)
+    C = B.orientnew('C', 'Axis', [q4, B.x])
+    v1 = q1 * A.z
+    v2 = q2*A.x + q3*B.y
+    v3 = q1*A.x + q2*A.y + q3*A.z
+    assert time_derivative(B.x, C) == 0
+    assert time_derivative(B.y, C) == - q4d*B.z
+    assert time_derivative(B.z, C) == q4d*B.y
+    assert time_derivative(v1, B) == q1d*A.z
+    assert time_derivative(v1, C) == - q1*sin(q)*q4d*A.x + \
+           q1*cos(q)*q4d*A.y + q1d*A.z
+    assert time_derivative(v2, A) == q2d*A.x - q3*qd*B.x + q3d*B.y
+    assert time_derivative(v2, C) == q2d*A.x - q2*qd*A.y + \
+           q2*sin(q)*q4d*A.z + q3d*B.y - q3*q4d*B.z
+    assert time_derivative(v3, B) == (q2*qd + q1d)*A.x + \
+           (-q1*qd + q2d)*A.y + q3d*A.z
+    assert time_derivative(d, C) == - qd*(A.y|A.x) + \
+           sin(q)*q4d*(A.z|A.x) - qd*(A.x|A.y) + sin(q)*q4d*(A.x|A.z)
+    raises(ValueError, lambda: time_derivative(B.x, C, order=0.5))
+    raises(ValueError, lambda: time_derivative(B.x, C, order=-1))
+
+
+def test_get_motion_methods():
+    #Initialization
+    t = dynamicsymbols._t
+    s1, s2, s3 = symbols('s1 s2 s3')
+    S1, S2, S3 = symbols('S1 S2 S3')
+    S4, S5, S6 = symbols('S4 S5 S6')
+    t1, t2 = symbols('t1 t2')
+    a, b, c = dynamicsymbols('a b c')
+    ad, bd, cd = dynamicsymbols('a b c', 1)
+    a2d, b2d, c2d = dynamicsymbols('a b c', 2)
+    v0 = S1*N.x + S2*N.y + S3*N.z
+    v01 = S4*N.x + S5*N.y + S6*N.z
+    v1 = s1*N.x + s2*N.y + s3*N.z
+    v2 = a*N.x + b*N.y + c*N.z
+    v2d = ad*N.x + bd*N.y + cd*N.z
+    v2dd = a2d*N.x + b2d*N.y + c2d*N.z
+    #Test position parameter
+    assert get_motion_params(frame = N) == (0, 0, 0)
+    assert get_motion_params(N, position=v1) == (0, 0, v1)
+    assert get_motion_params(N, position=v2) == (v2dd, v2d, v2)
+    #Test velocity parameter
+    assert get_motion_params(N, velocity=v1) == (0, v1, v1 * t)
+    assert get_motion_params(N, velocity=v1, position=v0, timevalue1=t1) == \
+           (0, v1, v0 + v1*(t - t1))
+    answer = get_motion_params(N, velocity=v1, position=v2, timevalue1=t1)
+    answer_expected = (0, v1, v1*t - v1*t1 + v2.subs(t, t1))
+    assert answer == answer_expected
+
+    answer = get_motion_params(N, velocity=v2, position=v0, timevalue1=t1)
+    integral_vector = Integral(a, (t, t1, t))*N.x + Integral(b, (t, t1, t))*N.y \
+            + Integral(c, (t, t1, t))*N.z
+    answer_expected = (v2d, v2, v0 + integral_vector)
+    assert answer == answer_expected
+
+    #Test acceleration parameter
+    assert get_motion_params(N, acceleration=v1) == \
+           (v1, v1 * t, v1 * t**2/2)
+    assert get_motion_params(N, acceleration=v1, velocity=v0,
+                          position=v2, timevalue1=t1, timevalue2=t2) == \
+           (v1, (v0 + v1*t - v1*t2),
+            -v0*t1 + v1*t**2/2 + v1*t2*t1 - \
+            v1*t1**2/2 + t*(v0 - v1*t2) + \
+            v2.subs(t, t1))
+    assert get_motion_params(N, acceleration=v1, velocity=v0,
+                             position=v01, timevalue1=t1, timevalue2=t2) == \
+           (v1, v0 + v1*t - v1*t2,
+            -v0*t1 + v01 + v1*t**2/2 + \
+            v1*t2*t1 - v1*t1**2/2 + \
+            t*(v0 - v1*t2))
+    answer = get_motion_params(N, acceleration=a*N.x, velocity=S1*N.x,
+                          position=S2*N.x, timevalue1=t1, timevalue2=t2)
+    i1 = Integral(a, (t, t2, t))
+    answer_expected = (a*N.x, (S1 + i1)*N.x, \
+        (S2 + Integral(S1 + i1, (t, t1, t)))*N.x)
+    assert answer == answer_expected
+
+
+def test_kin_eqs():
+    q0, q1, q2, q3 = dynamicsymbols('q0 q1 q2 q3')
+    q0d, q1d, q2d, q3d = dynamicsymbols('q0 q1 q2 q3', 1)
+    u1, u2, u3 = dynamicsymbols('u1 u2 u3')
+    ke = kinematic_equations([u1,u2,u3], [q1,q2,q3], 'body', 313)
+    assert ke == kinematic_equations([u1,u2,u3], [q1,q2,q3], 'body', '313')
+    kds = kinematic_equations([u1, u2, u3], [q0, q1, q2, q3], 'quaternion')
+    assert kds == [-0.5 * q0 * u1 - 0.5 * q2 * u3 + 0.5 * q3 * u2 + q1d,
+            -0.5 * q0 * u2 + 0.5 * q1 * u3 - 0.5 * q3 * u1 + q2d,
+            -0.5 * q0 * u3 - 0.5 * q1 * u2 + 0.5 * q2 * u1 + q3d,
+            0.5 * q1 * u1 + 0.5 * q2 * u2 + 0.5 * q3 * u3 + q0d]
+    raises(ValueError, lambda: kinematic_equations([u1, u2, u3], [q0, q1, q2], 'quaternion'))
+    raises(ValueError, lambda: kinematic_equations([u1, u2, u3], [q0, q1, q2, q3], 'quaternion', '123'))
+    raises(ValueError, lambda: kinematic_equations([u1, u2, u3], [q0, q1, q2, q3], 'foo'))
+    raises(TypeError, lambda: kinematic_equations(u1, [q0, q1, q2, q3], 'quaternion'))
+    raises(TypeError, lambda: kinematic_equations([u1], [q0, q1, q2, q3], 'quaternion'))
+    raises(TypeError, lambda: kinematic_equations([u1, u2, u3], q0, 'quaternion'))
+    raises(ValueError, lambda: kinematic_equations([u1, u2, u3], [q0, q1, q2, q3], 'body'))
+    raises(ValueError, lambda: kinematic_equations([u1, u2, u3], [q0, q1, q2, q3], 'space'))
+    raises(ValueError, lambda: kinematic_equations([u1, u2, u3], [q0, q1, q2], 'body', '222'))
+    assert kinematic_equations([0, 0, 0], [q0, q1, q2], 'space') == [S.Zero, S.Zero, S.Zero]
+
+
+def test_partial_velocity():
+    q1, q2, q3, u1, u2, u3 = dynamicsymbols('q1 q2 q3 u1 u2 u3')
+    u4, u5 = dynamicsymbols('u4, u5')
+    r = symbols('r')
+
+    N = ReferenceFrame('N')
+    Y = N.orientnew('Y', 'Axis', [q1, N.z])
+    L = Y.orientnew('L', 'Axis', [q2, Y.x])
+    R = L.orientnew('R', 'Axis', [q3, L.y])
+    R.set_ang_vel(N, u1 * L.x + u2 * L.y + u3 * L.z)
+
+    C = Point('C')
+    C.set_vel(N, u4 * L.x + u5 * (Y.z ^ L.x))
+    Dmc = C.locatenew('Dmc', r * L.z)
+    Dmc.v2pt_theory(C, N, R)
+
+    vel_list = [Dmc.vel(N), C.vel(N), R.ang_vel_in(N)]
+    u_list = [u1, u2, u3, u4, u5]
+    assert (partial_velocity(vel_list, u_list, N) ==
+            [[- r*L.y, r*L.x, 0, L.x, cos(q2)*L.y - sin(q2)*L.z],
+            [0, 0, 0, L.x, cos(q2)*L.y - sin(q2)*L.z],
+            [L.x, L.y, L.z, 0, 0]])
+
+    # Make sure that partial velocities can be computed regardless if the
+    # orientation between frames is defined or not.
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    v = u4 * A.x + u5 * B.y
+    assert partial_velocity((v, ), (u4, u5), A) == [[A.x, B.y]]
+
+    raises(TypeError, lambda: partial_velocity(Dmc.vel(N), u_list, N))
+    raises(TypeError, lambda: partial_velocity(vel_list, u1, N))
+
+def test_dynamicsymbols():
+    #Tests to check the assumptions applied to dynamicsymbols
+    f1 = dynamicsymbols('f1')
+    f2 = dynamicsymbols('f2', real=True)
+    f3 = dynamicsymbols('f3', positive=True)
+    f4, f5 = dynamicsymbols('f4,f5', commutative=False)
+    f6 = dynamicsymbols('f6', integer=True)
+    assert f1.is_real is None
+    assert f2.is_real
+    assert f3.is_positive
+    assert f4*f5 != f5*f4
+    assert f6.is_integer

venv/lib/python3.11/site-packages/sympy/physics/vector/tests/test_output.py

@@ -0,0 +1,75 @@
+from sympy.core.singleton import S
+from sympy.physics.vector import Vector, ReferenceFrame, Dyadic
+from sympy.testing.pytest import raises
+
+A = ReferenceFrame('A')
+
+
+def test_output_type():
+    A = ReferenceFrame('A')
+    v = A.x + A.y
+    d = v | v
+    zerov = Vector(0)
+    zerod = Dyadic(0)
+
+    # dot products
+    assert isinstance(d & d, Dyadic)
+    assert isinstance(d & zerod, Dyadic)
+    assert isinstance(zerod & d, Dyadic)
+    assert isinstance(d & v, Vector)
+    assert isinstance(v & d, Vector)
+    assert isinstance(d & zerov, Vector)
+    assert isinstance(zerov & d, Vector)
+    raises(TypeError, lambda: d & S.Zero)
+    raises(TypeError, lambda: S.Zero & d)
+    raises(TypeError, lambda: d & 0)
+    raises(TypeError, lambda: 0 & d)
+    assert not isinstance(v & v, (Vector, Dyadic))
+    assert not isinstance(v & zerov, (Vector, Dyadic))
+    assert not isinstance(zerov & v, (Vector, Dyadic))
+    raises(TypeError, lambda: v & S.Zero)
+    raises(TypeError, lambda: S.Zero & v)
+    raises(TypeError, lambda: v & 0)
+    raises(TypeError, lambda: 0 & v)
+
+    # cross products
+    raises(TypeError, lambda: d ^ d)
+    raises(TypeError, lambda: d ^ zerod)
+    raises(TypeError, lambda: zerod ^ d)
+    assert isinstance(d ^ v, Dyadic)
+    assert isinstance(v ^ d, Dyadic)
+    assert isinstance(d ^ zerov, Dyadic)
+    assert isinstance(zerov ^ d, Dyadic)
+    assert isinstance(zerov ^ d, Dyadic)
+    raises(TypeError, lambda: d ^ S.Zero)
+    raises(TypeError, lambda: S.Zero ^ d)
+    raises(TypeError, lambda: d ^ 0)
+    raises(TypeError, lambda: 0 ^ d)
+    assert isinstance(v ^ v, Vector)
+    assert isinstance(v ^ zerov, Vector)
+    assert isinstance(zerov ^ v, Vector)
+    raises(TypeError, lambda: v ^ S.Zero)
+    raises(TypeError, lambda: S.Zero ^ v)
+    raises(TypeError, lambda: v ^ 0)
+    raises(TypeError, lambda: 0 ^ v)
+
+    # outer products
+    raises(TypeError, lambda: d | d)
+    raises(TypeError, lambda: d | zerod)
+    raises(TypeError, lambda: zerod | d)
+    raises(TypeError, lambda: d | v)
+    raises(TypeError, lambda: v | d)
+    raises(TypeError, lambda: d | zerov)
+    raises(TypeError, lambda: zerov | d)
+    raises(TypeError, lambda: zerov | d)
+    raises(TypeError, lambda: d | S.Zero)
+    raises(TypeError, lambda: S.Zero | d)
+    raises(TypeError, lambda: d | 0)
+    raises(TypeError, lambda: 0 | d)
+    assert isinstance(v | v, Dyadic)
+    assert isinstance(v | zerov, Dyadic)
+    assert isinstance(zerov | v, Dyadic)
+    raises(TypeError, lambda: v | S.Zero)
+    raises(TypeError, lambda: S.Zero | v)
+    raises(TypeError, lambda: v | 0)
+    raises(TypeError, lambda: 0 | v)

venv/lib/python3.11/site-packages/sympy/physics/vector/tests/test_point.py

@@ -0,0 +1,382 @@
+from sympy.physics.vector import dynamicsymbols, Point, ReferenceFrame
+from sympy.testing.pytest import raises, ignore_warnings
+import warnings
+
+def test_point_v1pt_theorys():
+    q, q2 = dynamicsymbols('q q2')
+    qd, q2d = dynamicsymbols('q q2', 1)
+    qdd, q2dd = dynamicsymbols('q q2', 2)
+    N = ReferenceFrame('N')
+    B = ReferenceFrame('B')
+    B.set_ang_vel(N, qd * B.z)
+    O = Point('O')
+    P = O.locatenew('P', B.x)
+    P.set_vel(B, 0)
+    O.set_vel(N, 0)
+    assert P.v1pt_theory(O, N, B) == qd * B.y
+    O.set_vel(N, N.x)
+    assert P.v1pt_theory(O, N, B) == N.x + qd * B.y
+    P.set_vel(B, B.z)
+    assert P.v1pt_theory(O, N, B) == B.z + N.x + qd * B.y
+
+
+def test_point_a1pt_theorys():
+    q, q2 = dynamicsymbols('q q2')
+    qd, q2d = dynamicsymbols('q q2', 1)
+    qdd, q2dd = dynamicsymbols('q q2', 2)
+    N = ReferenceFrame('N')
+    B = ReferenceFrame('B')
+    B.set_ang_vel(N, qd * B.z)
+    O = Point('O')
+    P = O.locatenew('P', B.x)
+    P.set_vel(B, 0)
+    O.set_vel(N, 0)
+    assert P.a1pt_theory(O, N, B) == -(qd**2) * B.x + qdd * B.y
+    P.set_vel(B, q2d * B.z)
+    assert P.a1pt_theory(O, N, B) == -(qd**2) * B.x + qdd * B.y + q2dd * B.z
+    O.set_vel(N, q2d * B.x)
+    assert P.a1pt_theory(O, N, B) == ((q2dd - qd**2) * B.x + (q2d * qd + qdd) * B.y +
+                               q2dd * B.z)
+
+
+def test_point_v2pt_theorys():
+    q = dynamicsymbols('q')
+    qd = dynamicsymbols('q', 1)
+    N = ReferenceFrame('N')
+    B = N.orientnew('B', 'Axis', [q, N.z])
+    O = Point('O')
+    P = O.locatenew('P', 0)
+    O.set_vel(N, 0)
+    assert P.v2pt_theory(O, N, B) == 0
+    P = O.locatenew('P', B.x)
+    assert P.v2pt_theory(O, N, B) == (qd * B.z ^ B.x)
+    O.set_vel(N, N.x)
+    assert P.v2pt_theory(O, N, B) == N.x + qd * B.y
+
+
+def test_point_a2pt_theorys():
+    q = dynamicsymbols('q')
+    qd = dynamicsymbols('q', 1)
+    qdd = dynamicsymbols('q', 2)
+    N = ReferenceFrame('N')
+    B = N.orientnew('B', 'Axis', [q, N.z])
+    O = Point('O')
+    P = O.locatenew('P', 0)
+    O.set_vel(N, 0)
+    assert P.a2pt_theory(O, N, B) == 0
+    P.set_pos(O, B.x)
+    assert P.a2pt_theory(O, N, B) == (-qd**2) * B.x + (qdd) * B.y
+
+
+def test_point_funcs():
+    q, q2 = dynamicsymbols('q q2')
+    qd, q2d = dynamicsymbols('q q2', 1)
+    qdd, q2dd = dynamicsymbols('q q2', 2)
+    N = ReferenceFrame('N')
+    B = ReferenceFrame('B')
+    B.set_ang_vel(N, 5 * B.y)
+    O = Point('O')
+    P = O.locatenew('P', q * B.x + q2 * B.y)
+    assert P.pos_from(O) == q * B.x + q2 * B.y
+    P.set_vel(B, qd * B.x + q2d * B.y)
+    assert P.vel(B) == qd * B.x + q2d * B.y
+    O.set_vel(N, 0)
+    assert O.vel(N) == 0
+    assert P.a1pt_theory(O, N, B) == ((-25 * q + qdd) * B.x + (q2dd) * B.y +
+                               (-10 * qd) * B.z)
+
+    B = N.orientnew('B', 'Axis', [q, N.z])
+    O = Point('O')
+    P = O.locatenew('P', 10 * B.x)
+    O.set_vel(N, 5 * N.x)
+    assert O.vel(N) == 5 * N.x
+    assert P.a2pt_theory(O, N, B) == (-10 * qd**2) * B.x + (10 * qdd) * B.y
+
+    B.set_ang_vel(N, 5 * B.y)
+    O = Point('O')
+    P = O.locatenew('P', q * B.x + q2 * B.y)
+    P.set_vel(B, qd * B.x + q2d * B.y)
+    O.set_vel(N, 0)
+    assert P.v1pt_theory(O, N, B) == qd * B.x + q2d * B.y - 5 * q * B.z
+
+
+def test_point_pos():
+    q = dynamicsymbols('q')
+    N = ReferenceFrame('N')
+    B = N.orientnew('B', 'Axis', [q, N.z])
+    O = Point('O')
+    P = O.locatenew('P', 10 * N.x + 5 * B.x)
+    assert P.pos_from(O) == 10 * N.x + 5 * B.x
+    Q = P.locatenew('Q', 10 * N.y + 5 * B.y)
+    assert Q.pos_from(P) == 10 * N.y + 5 * B.y
+    assert Q.pos_from(O) == 10 * N.x + 10 * N.y + 5 * B.x + 5 * B.y
+    assert O.pos_from(Q) == -10 * N.x - 10 * N.y - 5 * B.x - 5 * B.y
+
+def test_point_partial_velocity():
+
+    N = ReferenceFrame('N')
+    A = ReferenceFrame('A')
+
+    p = Point('p')
+
+    u1, u2 = dynamicsymbols('u1, u2')
+
+    p.set_vel(N, u1 * A.x + u2 * N.y)
+
+    assert p.partial_velocity(N, u1) == A.x
+    assert p.partial_velocity(N, u1, u2) == (A.x, N.y)
+    raises(ValueError, lambda: p.partial_velocity(A, u1))
+
+def test_point_vel(): #Basic functionality
+    q1, q2 = dynamicsymbols('q1 q2')
+    N = ReferenceFrame('N')
+    B = ReferenceFrame('B')
+    Q = Point('Q')
+    O = Point('O')
+    Q.set_pos(O, q1 * N.x)
+    raises(ValueError , lambda: Q.vel(N)) # Velocity of O in N is not defined
+    O.set_vel(N, q2 * N.y)
+    assert O.vel(N) == q2 * N.y
+    raises(ValueError , lambda : O.vel(B)) #Velocity of O is not defined in B
+
+def test_auto_point_vel():
+    t = dynamicsymbols._t
+    q1, q2 = dynamicsymbols('q1 q2')
+    N = ReferenceFrame('N')
+    B = ReferenceFrame('B')
+    O = Point('O')
+    Q = Point('Q')
+    Q.set_pos(O, q1 * N.x)
+    O.set_vel(N, q2 * N.y)
+    assert Q.vel(N) == q1.diff(t) * N.x + q2 * N.y  # Velocity of Q using O
+    P1 = Point('P1')
+    P1.set_pos(O, q1 * B.x)
+    P2 = Point('P2')
+    P2.set_pos(P1, q2 * B.z)
+    raises(ValueError, lambda : P2.vel(B)) # O's velocity is defined in different frame, and no
+    #point in between has its velocity defined
+    raises(ValueError, lambda: P2.vel(N)) # Velocity of O not defined in N
+
+def test_auto_point_vel_multiple_point_path():
+    t = dynamicsymbols._t
+    q1, q2 = dynamicsymbols('q1 q2')
+    B = ReferenceFrame('B')
+    P = Point('P')
+    P.set_vel(B, q1 * B.x)
+    P1 = Point('P1')
+    P1.set_pos(P, q2 * B.y)
+    P1.set_vel(B, q1 * B.z)
+    P2 = Point('P2')
+    P2.set_pos(P1, q1 * B.z)
+    P3 = Point('P3')
+    P3.set_pos(P2, 10 * q1 * B.y)
+    assert P3.vel(B) == 10 * q1.diff(t) * B.y + (q1 + q1.diff(t)) * B.z
+
+def test_auto_vel_dont_overwrite():
+    t = dynamicsymbols._t
+    q1, q2, u1 = dynamicsymbols('q1, q2, u1')
+    N = ReferenceFrame('N')
+    P = Point('P1')
+    P.set_vel(N, u1 * N.x)
+    P1 = Point('P1')
+    P1.set_pos(P, q2 * N.y)
+    assert P1.vel(N) == q2.diff(t) * N.y + u1 * N.x
+    assert P.vel(N) == u1 * N.x
+    P1.set_vel(N, u1 * N.z)
+    assert P1.vel(N) == u1 * N.z
+
+def test_auto_point_vel_if_tree_has_vel_but_inappropriate_pos_vector():
+    q1, q2 = dynamicsymbols('q1 q2')
+    B = ReferenceFrame('B')
+    S = ReferenceFrame('S')
+    P = Point('P')
+    P.set_vel(B, q1 * B.x)
+    P1 = Point('P1')
+    P1.set_pos(P, S.y)
+    raises(ValueError, lambda : P1.vel(B)) # P1.pos_from(P) can't be expressed in B
+    raises(ValueError, lambda : P1.vel(S)) # P.vel(S) not defined
+
+def test_auto_point_vel_shortest_path():
+    t = dynamicsymbols._t
+    q1, q2, u1, u2 = dynamicsymbols('q1 q2 u1 u2')
+    B = ReferenceFrame('B')
+    P = Point('P')
+    P.set_vel(B, u1 * B.x)
+    P1 = Point('P1')
+    P1.set_pos(P, q2 * B.y)
+    P1.set_vel(B, q1 * B.z)
+    P2 = Point('P2')
+    P2.set_pos(P1, q1 * B.z)
+    P3 = Point('P3')
+    P3.set_pos(P2, 10 * q1 * B.y)
+    P4 = Point('P4')
+    P4.set_pos(P3, q1 * B.x)
+    O = Point('O')
+    O.set_vel(B, u2 * B.y)
+    O1 = Point('O1')
+    O1.set_pos(O, q2 * B.z)
+    P4.set_pos(O1, q1 * B.x + q2 * B.z)
+    with warnings.catch_warnings(): #There are two possible paths in this point tree, thus a warning is raised
+        warnings.simplefilter('error')
+        with ignore_warnings(UserWarning):
+            assert P4.vel(B) == q1.diff(t) * B.x + u2 * B.y + 2 * q2.diff(t) * B.z
+
+def test_auto_point_vel_connected_frames():
+    t = dynamicsymbols._t
+    q, q1, q2, u = dynamicsymbols('q q1 q2 u')
+    N = ReferenceFrame('N')
+    B = ReferenceFrame('B')
+    O = Point('O')
+    O.set_vel(N, u * N.x)
+    P = Point('P')
+    P.set_pos(O, q1 * N.x + q2 * B.y)
+    raises(ValueError, lambda: P.vel(N))
+    N.orient(B, 'Axis', (q, B.x))
+    assert P.vel(N) == (u + q1.diff(t)) * N.x + q2.diff(t) * B.y - q2 * q.diff(t) * B.z
+
+def test_auto_point_vel_multiple_paths_warning_arises():
+    q, u = dynamicsymbols('q u')
+    N = ReferenceFrame('N')
+    O = Point('O')
+    P = Point('P')
+    Q = Point('Q')
+    R = Point('R')
+    P.set_vel(N, u * N.x)
+    Q.set_vel(N, u *N.y)
+    R.set_vel(N, u * N.z)
+    O.set_pos(P, q * N.z)
+    O.set_pos(Q, q * N.y)
+    O.set_pos(R, q * N.x)
+    with warnings.catch_warnings(): #There are two possible paths in this point tree, thus a warning is raised
+        warnings.simplefilter("error")
+        raises(UserWarning ,lambda: O.vel(N))
+
+def test_auto_vel_cyclic_warning_arises():
+    P = Point('P')
+    P1 = Point('P1')
+    P2 = Point('P2')
+    P3 = Point('P3')
+    N = ReferenceFrame('N')
+    P.set_vel(N, N.x)
+    P1.set_pos(P, N.x)
+    P2.set_pos(P1, N.y)
+    P3.set_pos(P2, N.z)
+    P1.set_pos(P3, N.x + N.y)
+    with warnings.catch_warnings(): #The path is cyclic at P1, thus a warning is raised
+        warnings.simplefilter("error")
+        raises(UserWarning ,lambda: P2.vel(N))
+
+def test_auto_vel_cyclic_warning_msg():
+    P = Point('P')
+    P1 = Point('P1')
+    P2 = Point('P2')
+    P3 = Point('P3')
+    N = ReferenceFrame('N')
+    P.set_vel(N, N.x)
+    P1.set_pos(P, N.x)
+    P2.set_pos(P1, N.y)
+    P3.set_pos(P2, N.z)
+    P1.set_pos(P3, N.x + N.y)
+    with warnings.catch_warnings(record = True) as w: #The path is cyclic at P1, thus a warning is raised
+        warnings.simplefilter("always")
+        P2.vel(N)
+        msg = str(w[-1].message).replace("\n", " ")
+        assert issubclass(w[-1].category, UserWarning)
+        assert 'Kinematic loops are defined among the positions of points. This is likely not desired and may cause errors in your calculations.' in msg
+
+def test_auto_vel_multiple_path_warning_msg():
+    N = ReferenceFrame('N')
+    O = Point('O')
+    P = Point('P')
+    Q = Point('Q')
+    P.set_vel(N, N.x)
+    Q.set_vel(N, N.y)
+    O.set_pos(P, N.z)
+    O.set_pos(Q, N.y)
+    with warnings.catch_warnings(record = True) as w: #There are two possible paths in this point tree, thus a warning is raised
+        warnings.simplefilter("always")
+        O.vel(N)
+        msg = str(w[-1].message).replace("\n", " ")
+        assert issubclass(w[-1].category, UserWarning)
+        assert 'Velocity' in msg
+        assert 'automatically calculated based on point' in msg
+        assert 'Velocities from these points are not necessarily the same. This may cause errors in your calculations.' in msg
+
+def test_auto_vel_derivative():
+    q1, q2 = dynamicsymbols('q1:3')
+    u1, u2 = dynamicsymbols('u1:3', 1)
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    C = ReferenceFrame('C')
+    B.orient_axis(A, A.z, q1)
+    B.set_ang_vel(A, u1 * A.z)
+    C.orient_axis(B, B.z, q2)
+    C.set_ang_vel(B, u2 * B.z)
+
+    Am = Point('Am')
+    Am.set_vel(A, 0)
+    Bm = Point('Bm')
+    Bm.set_pos(Am, B.x)
+    Bm.set_vel(B, 0)
+    Bm.set_vel(C, 0)
+    Cm = Point('Cm')
+    Cm.set_pos(Bm, C.x)
+    Cm.set_vel(C, 0)
+    temp = Cm._vel_dict.copy()
+    assert Cm.vel(A) == (u1 * B.y + (u1 + u2) * C.y)
+    Cm._vel_dict = temp
+    Cm.v2pt_theory(Bm, B, C)
+    assert Cm.vel(A) == (u1 * B.y + (u1 + u2) * C.y)
+
+def test_auto_point_acc_zero_vel():
+    N = ReferenceFrame('N')
+    O = Point('O')
+    O.set_vel(N, 0)
+    assert O.acc(N) == 0 * N.x
+
+def test_auto_point_acc_compute_vel():
+    t = dynamicsymbols._t
+    q1 = dynamicsymbols('q1')
+    N = ReferenceFrame('N')
+    A = ReferenceFrame('A')
+    A.orient_axis(N, N.z, q1)
+
+    O = Point('O')
+    O.set_vel(N, 0)
+    P = Point('P')
+    P.set_pos(O, A.x)
+    assert P.acc(N) == -q1.diff(t) ** 2 * A.x + q1.diff(t, 2) * A.y
+
+def test_auto_acc_derivative():
+    # Tests whether the Point.acc method gives the correct acceleration of the
+    # end point of two linkages in series, while getting minimal information.
+    q1, q2 = dynamicsymbols('q1:3')
+    u1, u2 = dynamicsymbols('q1:3', 1)
+    v1, v2 = dynamicsymbols('q1:3', 2)
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    C = ReferenceFrame('C')
+    B.orient_axis(A, A.z, q1)
+    C.orient_axis(B, B.z, q2)
+
+    Am = Point('Am')
+    Am.set_vel(A, 0)
+    Bm = Point('Bm')
+    Bm.set_pos(Am, B.x)
+    Bm.set_vel(B, 0)
+    Bm.set_vel(C, 0)
+    Cm = Point('Cm')
+    Cm.set_pos(Bm, C.x)
+    Cm.set_vel(C, 0)
+
+    # Copy dictionaries to later check the calculation using the 2pt_theories
+    Bm_vel_dict, Cm_vel_dict = Bm._vel_dict.copy(), Cm._vel_dict.copy()
+    Bm_acc_dict, Cm_acc_dict = Bm._acc_dict.copy(), Cm._acc_dict.copy()
+    check = -u1 ** 2 * B.x + v1 * B.y - (u1 + u2) ** 2 * C.x + (v1 + v2) * C.y
+    assert Cm.acc(A) == check
+    Bm._vel_dict, Cm._vel_dict = Bm_vel_dict, Cm_vel_dict
+    Bm._acc_dict, Cm._acc_dict = Bm_acc_dict, Cm_acc_dict
+    Bm.v2pt_theory(Am, A, B)
+    Cm.v2pt_theory(Bm, A, C)
+    Bm.a2pt_theory(Am, A, B)
+    assert Cm.a2pt_theory(Bm, A, C) == check

venv/lib/python3.11/site-packages/sympy/physics/vector/tests/test_printing.py

@@ -0,0 +1,353 @@
+# -*- coding: utf-8 -*-
+
+from sympy.core.function import Function
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (asin, cos, sin)
+from sympy.physics.vector import ReferenceFrame, dynamicsymbols, Dyadic
+from sympy.physics.vector.printing import (VectorLatexPrinter, vpprint,
+                                           vsprint, vsstrrepr, vlatex)
+
+
+a, b, c = symbols('a, b, c')
+alpha, omega, beta = dynamicsymbols('alpha, omega, beta')
+
+A = ReferenceFrame('A')
+N = ReferenceFrame('N')
+
+v = a ** 2 * N.x + b * N.y + c * sin(alpha) * N.z
+w = alpha * N.x + sin(omega) * N.y + alpha * beta * N.z
+ww = alpha * N.x + asin(omega) * N.y - alpha.diff() * beta * N.z
+o = a/b * N.x + (c+b)/a * N.y + c**2/b * N.z
+
+y = a ** 2 * (N.x | N.y) + b * (N.y | N.y) + c * sin(alpha) * (N.z | N.y)
+x = alpha * (N.x | N.x) + sin(omega) * (N.y | N.z) + alpha * beta * (N.z | N.x)
+xx = N.x | (-N.y - N.z)
+xx2 = N.x | (N.y + N.z)
+
+def ascii_vpretty(expr):
+    return vpprint(expr, use_unicode=False, wrap_line=False)
+
+
+def unicode_vpretty(expr):
+    return vpprint(expr, use_unicode=True, wrap_line=False)
+
+
+def test_latex_printer():
+    r = Function('r')('t')
+    assert VectorLatexPrinter().doprint(r ** 2) == "r^{2}"
+    r2 = Function('r^2')('t')
+    assert VectorLatexPrinter().doprint(r2.diff()) == r'\dot{r^{2}}'
+    ra = Function('r__a')('t')
+    assert VectorLatexPrinter().doprint(ra.diff().diff()) == r'\ddot{r^{a}}'
+
+
+def test_vector_pretty_print():
+
+    # TODO : The unit vectors should print with subscripts but they just
+    # print as `n_x` instead of making `x` a subscript with unicode.
+
+    # TODO : The pretty print division does not print correctly here:
+    # w = alpha * N.x + sin(omega) * N.y + alpha / beta * N.z
+
+    expected = """\
+ 2                               \n\
+a  n_x + b n_y + c*sin(alpha) n_z\
+"""
+    uexpected = """\
+ 2                           \n\
+a  n_x + b n_y + c⋅sin(α) n_z\
+"""
+
+    assert ascii_vpretty(v) == expected
+    assert unicode_vpretty(v) == uexpected
+
+    expected = 'alpha n_x + sin(omega) n_y + alpha*beta n_z'
+    uexpected = 'α n_x + sin(ω) n_y + α⋅β n_z'
+
+    assert ascii_vpretty(w) == expected
+    assert unicode_vpretty(w) == uexpected
+
+    expected = """\
+                     2    \n\
+a       b + c       c     \n\
+- n_x + ----- n_y + -- n_z\n\
+b         a         b     \
+"""
+    uexpected = """\
+                     2    \n\
+a       b + c       c     \n\
+─ n_x + ───── n_y + ── n_z\n\
+b         a         b     \
+"""
+
+    assert ascii_vpretty(o) == expected
+    assert unicode_vpretty(o) == uexpected
+
+    # https://github.com/sympy/sympy/issues/26731
+    assert ascii_vpretty(-A.x) == '-a_x'
+    assert unicode_vpretty(-A.x) == '-a_x'
+
+    # https://github.com/sympy/sympy/issues/26799
+    assert ascii_vpretty(0*A.x) == '0'
+    assert unicode_vpretty(0*A.x) == '0'
+
+
+def test_vector_latex():
+
+    a, b, c, d, omega = symbols('a, b, c, d, omega')
+
+    v = (a ** 2 + b / c) * A.x + sqrt(d) * A.y + cos(omega) * A.z
+
+    assert vlatex(v) == (r'(a^{2} + \frac{b}{c})\mathbf{\hat{a}_x} + '
+                         r'\sqrt{d}\mathbf{\hat{a}_y} + '
+                         r'\cos{\left(\omega \right)}'
+                         r'\mathbf{\hat{a}_z}')
+
+    theta, omega, alpha, q = dynamicsymbols('theta, omega, alpha, q')
+
+    v = theta * A.x + omega * omega * A.y + (q * alpha) * A.z
+
+    assert vlatex(v) == (r'\theta\mathbf{\hat{a}_x} + '
+                         r'\omega^{2}\mathbf{\hat{a}_y} + '
+                         r'\alpha q\mathbf{\hat{a}_z}')
+
+    phi1, phi2, phi3 = dynamicsymbols('phi1, phi2, phi3')
+    theta1, theta2, theta3 = symbols('theta1, theta2, theta3')
+
+    v = (sin(theta1) * A.x +
+         cos(phi1) * cos(phi2) * A.y +
+         cos(theta1 + phi3) * A.z)
+
+    assert vlatex(v) == (r'\sin{\left(\theta_{1} \right)}'
+                         r'\mathbf{\hat{a}_x} + \cos{'
+                         r'\left(\phi_{1} \right)} \cos{'
+                         r'\left(\phi_{2} \right)}\mathbf{\hat{a}_y} + '
+                         r'\cos{\left(\theta_{1} + '
+                         r'\phi_{3} \right)}\mathbf{\hat{a}_z}')
+
+    N = ReferenceFrame('N')
+
+    a, b, c, d, omega = symbols('a, b, c, d, omega')
+
+    v = (a ** 2 + b / c) * N.x + sqrt(d) * N.y + cos(omega) * N.z
+
+    expected = (r'(a^{2} + \frac{b}{c})\mathbf{\hat{n}_x} + '
+                r'\sqrt{d}\mathbf{\hat{n}_y} + '
+                r'\cos{\left(\omega \right)}'
+                r'\mathbf{\hat{n}_z}')
+
+    assert vlatex(v) == expected
+
+    # Try custom unit vectors.
+
+    N = ReferenceFrame('N', latexs=(r'\hat{i}', r'\hat{j}', r'\hat{k}'))
+
+    v = (a ** 2 + b / c) * N.x + sqrt(d) * N.y + cos(omega) * N.z
+
+    expected = (r'(a^{2} + \frac{b}{c})\hat{i} + '
+                r'\sqrt{d}\hat{j} + '
+                r'\cos{\left(\omega \right)}\hat{k}')
+    assert vlatex(v) == expected
+
+    expected = r'\alpha\mathbf{\hat{n}_x} + \operatorname{asin}{\left(\omega ' \
+        r'\right)}\mathbf{\hat{n}_y} -  \beta \dot{\alpha}\mathbf{\hat{n}_z}'
+    assert vlatex(ww) == expected
+
+    expected = r'- \mathbf{\hat{n}_x}\otimes \mathbf{\hat{n}_y} - ' \
+        r'\mathbf{\hat{n}_x}\otimes \mathbf{\hat{n}_z}'
+    assert vlatex(xx) == expected
+
+    expected = r'\mathbf{\hat{n}_x}\otimes \mathbf{\hat{n}_y} + ' \
+        r'\mathbf{\hat{n}_x}\otimes \mathbf{\hat{n}_z}'
+    assert vlatex(xx2) == expected
+
+
+def test_vector_latex_arguments():
+    assert vlatex(N.x * 3.0, full_prec=False) == r'3.0\mathbf{\hat{n}_x}'
+    assert vlatex(N.x * 3.0, full_prec=True) == r'3.00000000000000\mathbf{\hat{n}_x}'
+
+
+def test_vector_latex_with_functions():
+
+    N = ReferenceFrame('N')
+
+    omega, alpha = dynamicsymbols('omega, alpha')
+
+    v = omega.diff() * N.x
+
+    assert vlatex(v) == r'\dot{\omega}\mathbf{\hat{n}_x}'
+
+    v = omega.diff() ** alpha * N.x
+
+    assert vlatex(v) == (r'\dot{\omega}^{\alpha}'
+                          r'\mathbf{\hat{n}_x}')
+
+
+def test_dyadic_pretty_print():
+
+    expected = """\
+ 2
+a  n_x|n_y + b n_y|n_y + c*sin(alpha) n_z|n_y\
+"""
+
+    uexpected = """\
+ 2
+a  n_x⊗n_y + b n_y⊗n_y + c⋅sin(α) n_z⊗n_y\
+"""
+    assert ascii_vpretty(y) == expected
+    assert unicode_vpretty(y) == uexpected
+
+    expected = 'alpha n_x|n_x + sin(omega) n_y|n_z + alpha*beta n_z|n_x'
+    uexpected = 'α n_x⊗n_x + sin(ω) n_y⊗n_z + α⋅β n_z⊗n_x'
+    assert ascii_vpretty(x) == expected
+    assert unicode_vpretty(x) == uexpected
+
+    assert ascii_vpretty(Dyadic([])) == '0'
+    assert unicode_vpretty(Dyadic([])) == '0'
+
+    assert ascii_vpretty(xx) == '- n_x|n_y - n_x|n_z'
+    assert unicode_vpretty(xx) == '- n_x⊗n_y - n_x⊗n_z'
+
+    assert ascii_vpretty(xx2) == 'n_x|n_y + n_x|n_z'
+    assert unicode_vpretty(xx2) == 'n_x⊗n_y + n_x⊗n_z'
+
+
+def test_dyadic_latex():
+
+    expected = (r'a^{2}\mathbf{\hat{n}_x}\otimes \mathbf{\hat{n}_y} + '
+                r'b\mathbf{\hat{n}_y}\otimes \mathbf{\hat{n}_y} + '
+                r'c \sin{\left(\alpha \right)}'
+                r'\mathbf{\hat{n}_z}\otimes \mathbf{\hat{n}_y}')
+
+    assert vlatex(y) == expected
+
+    expected = (r'\alpha\mathbf{\hat{n}_x}\otimes \mathbf{\hat{n}_x} + '
+                r'\sin{\left(\omega \right)}\mathbf{\hat{n}_y}'
+                r'\otimes \mathbf{\hat{n}_z} + '
+                r'\alpha \beta\mathbf{\hat{n}_z}\otimes \mathbf{\hat{n}_x}')
+
+    assert vlatex(x) == expected
+
+    assert vlatex(Dyadic([])) == '0'
+
+
+def test_dyadic_str():
+    assert vsprint(Dyadic([])) == '0'
+    assert vsprint(y) == 'a**2*(N.x|N.y) + b*(N.y|N.y) + c*sin(alpha)*(N.z|N.y)'
+    assert vsprint(x) == 'alpha*(N.x|N.x) + sin(omega)*(N.y|N.z) + alpha*beta*(N.z|N.x)'
+    assert vsprint(ww) == "alpha*N.x + asin(omega)*N.y - beta*alpha'*N.z"
+    assert vsprint(xx) == '- (N.x|N.y) - (N.x|N.z)'
+    assert vsprint(xx2) == '(N.x|N.y) + (N.x|N.z)'
+
+
+def test_vlatex(): # vlatex is broken #12078
+    from sympy.physics.vector import vlatex
+
+    x = symbols('x')
+    J = symbols('J')
+
+    f = Function('f')
+    g = Function('g')
+    h = Function('h')
+
+    expected = r'J \left(\frac{d}{d x} g{\left(x \right)} - \frac{d}{d x} h{\left(x \right)}\right)'
+
+    expr = J*f(x).diff(x).subs(f(x), g(x)-h(x))
+
+    assert vlatex(expr) == expected
+
+
+def test_issue_13354():
+    """
+    Test for proper pretty printing of physics vectors with ADD
+    instances in arguments.
+
+    Test is exactly the one suggested in the original bug report by
+    @moorepants.
+    """
+
+    a, b, c = symbols('a, b, c')
+    A = ReferenceFrame('A')
+    v = a * A.x + b * A.y + c * A.z
+    w = b * A.x + c * A.y + a * A.z
+    z = w + v
+
+    expected = """(a + b) a_x + (b + c) a_y + (a + c) a_z"""
+
+    assert ascii_vpretty(z) == expected
+
+
+def test_vector_derivative_printing():
+    # First order
+    v = omega.diff() * N.x
+    assert unicode_vpretty(v) == 'ω̇ n_x'
+    assert ascii_vpretty(v) == "omega'(t) n_x"
+
+    # Second order
+    v = omega.diff().diff() * N.x
+
+    assert vlatex(v) == r'\ddot{\omega}\mathbf{\hat{n}_x}'
+    assert unicode_vpretty(v) == 'ω̈ n_x'
+    assert ascii_vpretty(v) == "omega''(t) n_x"
+
+    # Third order
+    v = omega.diff().diff().diff() * N.x
+
+    assert vlatex(v) == r'\dddot{\omega}\mathbf{\hat{n}_x}'
+    assert unicode_vpretty(v) == 'ω⃛ n_x'
+    assert ascii_vpretty(v) == "omega'''(t) n_x"
+
+    # Fourth order
+    v = omega.diff().diff().diff().diff() * N.x
+
+    assert vlatex(v) == r'\ddddot{\omega}\mathbf{\hat{n}_x}'
+    assert unicode_vpretty(v) == 'ω⃜ n_x'
+    assert ascii_vpretty(v) == "omega''''(t) n_x"
+
+    # Fifth order
+    v = omega.diff().diff().diff().diff().diff() * N.x
+
+    assert vlatex(v) == r'\frac{d^{5}}{d t^{5}} \omega\mathbf{\hat{n}_x}'
+    expected = '''\
+ 5            \n\
+d             \n\
+---(omega) n_x\n\
+  5           \n\
+dt            \
+'''
+    uexpected = '''\
+ 5        \n\
+d         \n\
+───(ω) n_x\n\
+  5       \n\
+dt        \
+'''
+    assert unicode_vpretty(v) == uexpected
+    assert ascii_vpretty(v) == expected
+
+
+def test_vector_str_printing():
+    assert vsprint(w) == 'alpha*N.x + sin(omega)*N.y + alpha*beta*N.z'
+    assert vsprint(omega.diff() * N.x) == "omega'*N.x"
+    assert vsstrrepr(w) == 'alpha*N.x + sin(omega)*N.y + alpha*beta*N.z'
+
+
+def test_vector_str_arguments():
+    assert vsprint(N.x * 3.0, full_prec=False) == '3.0*N.x'
+    assert vsprint(N.x * 3.0, full_prec=True) == '3.00000000000000*N.x'
+
+
+def test_issue_14041():
+    import sympy.physics.mechanics as me
+
+    A_frame = me.ReferenceFrame('A')
+    thetad, phid = me.dynamicsymbols('theta, phi', 1)
+    L = symbols('L')
+
+    assert vlatex(L*(phid + thetad)**2*A_frame.x) == \
+        r"L \left(\dot{\phi} + \dot{\theta}\right)^{2}\mathbf{\hat{a}_x}"
+    assert vlatex((phid + thetad)**2*A_frame.x) == \
+        r"\left(\dot{\phi} + \dot{\theta}\right)^{2}\mathbf{\hat{a}_x}"
+    assert vlatex((phid*thetad)**a*A_frame.x) == \
+        r"\left(\dot{\phi} \dot{\theta}\right)^{a}\mathbf{\hat{a}_x}"

venv/lib/python3.11/site-packages/sympy/physics/vector/tests/test_vector.py

@@ -0,0 +1,274 @@
+from sympy.core.numbers import (Float, pi)
+from sympy.core.symbol import symbols
+from sympy.core.sorting import ordered
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.matrices.immutable import ImmutableDenseMatrix as Matrix
+from sympy.physics.vector import ReferenceFrame, Vector, dynamicsymbols, dot
+from sympy.physics.vector.vector import VectorTypeError
+from sympy.abc import x, y, z
+from sympy.testing.pytest import raises
+
+A = ReferenceFrame('A')
+
+
+def test_free_dynamicsymbols():
+    A, B, C, D = symbols('A, B, C, D', cls=ReferenceFrame)
+    a, b, c, d, e, f = dynamicsymbols('a, b, c, d, e, f')
+    B.orient_axis(A, a, A.x)
+    C.orient_axis(B, b, B.y)
+    D.orient_axis(C, c, C.x)
+
+    v = d*D.x + e*D.y + f*D.z
+
+    assert set(ordered(v.free_dynamicsymbols(A))) == {a, b, c, d, e, f}
+    assert set(ordered(v.free_dynamicsymbols(B))) == {b, c, d, e, f}
+    assert set(ordered(v.free_dynamicsymbols(C))) == {c, d, e, f}
+    assert set(ordered(v.free_dynamicsymbols(D))) == {d, e, f}
+
+
+def test_Vector():
+    assert A.x != A.y
+    assert A.y != A.z
+    assert A.z != A.x
+
+    assert A.x + 0 == A.x
+
+    v1 = x*A.x + y*A.y + z*A.z
+    v2 = x**2*A.x + y**2*A.y + z**2*A.z
+    v3 = v1 + v2
+    v4 = v1 - v2
+
+    assert isinstance(v1, Vector)
+    assert dot(v1, A.x) == x
+    assert dot(v1, A.y) == y
+    assert dot(v1, A.z) == z
+
+    assert isinstance(v2, Vector)
+    assert dot(v2, A.x) == x**2
+    assert dot(v2, A.y) == y**2
+    assert dot(v2, A.z) == z**2
+
+    assert isinstance(v3, Vector)
+    # We probably shouldn't be using simplify in dot...
+    assert dot(v3, A.x) == x**2 + x
+    assert dot(v3, A.y) == y**2 + y
+    assert dot(v3, A.z) == z**2 + z
+
+    assert isinstance(v4, Vector)
+    # We probably shouldn't be using simplify in dot...
+    assert dot(v4, A.x) == x - x**2
+    assert dot(v4, A.y) == y - y**2
+    assert dot(v4, A.z) == z - z**2
+
+    assert v1.to_matrix(A) == Matrix([[x], [y], [z]])
+    q = symbols('q')
+    B = A.orientnew('B', 'Axis', (q, A.x))
+    assert v1.to_matrix(B) == Matrix([[x],
+                                      [ y * cos(q) + z * sin(q)],
+                                      [-y * sin(q) + z * cos(q)]])
+
+    #Test the separate method
+    B = ReferenceFrame('B')
+    v5 = x*A.x + y*A.y + z*B.z
+    assert Vector(0).separate() == {}
+    assert v1.separate() == {A: v1}
+    assert v5.separate() == {A: x*A.x + y*A.y, B: z*B.z}
+
+    #Test the free_symbols property
+    v6 = x*A.x + y*A.y + z*A.z
+    assert v6.free_symbols(A) == {x,y,z}
+
+    raises(TypeError, lambda: v3.applyfunc(v1))
+
+
+def test_Vector_diffs():
+    q1, q2, q3, q4 = dynamicsymbols('q1 q2 q3 q4')
+    q1d, q2d, q3d, q4d = dynamicsymbols('q1 q2 q3 q4', 1)
+    q1dd, q2dd, q3dd, q4dd = dynamicsymbols('q1 q2 q3 q4', 2)
+    N = ReferenceFrame('N')
+    A = N.orientnew('A', 'Axis', [q3, N.z])
+    B = A.orientnew('B', 'Axis', [q2, A.x])
+    v1 = q2 * A.x + q3 * N.y
+    v2 = q3 * B.x + v1
+    v3 = v1.dt(B)
+    v4 = v2.dt(B)
+    v5 = q1*A.x + q2*A.y + q3*A.z
+
+    assert v1.dt(N) == q2d * A.x + q2 * q3d * A.y + q3d * N.y
+    assert v1.dt(A) == q2d * A.x + q3 * q3d * N.x + q3d * N.y
+    assert v1.dt(B) == (q2d * A.x + q3 * q3d * N.x + q3d *
+                        N.y - q3 * cos(q3) * q2d * N.z)
+    assert v2.dt(N) == (q2d * A.x + (q2 + q3) * q3d * A.y + q3d * B.x + q3d *
+                        N.y)
+    assert v2.dt(A) == q2d * A.x + q3d * B.x + q3 * q3d * N.x + q3d * N.y
+    assert v2.dt(B) == (q2d * A.x + q3d * B.x + q3 * q3d * N.x + q3d * N.y -
+                        q3 * cos(q3) * q2d * N.z)
+    assert v3.dt(N) == (q2dd * A.x + q2d * q3d * A.y + (q3d**2 + q3 * q3dd) *
+                        N.x + q3dd * N.y + (q3 * sin(q3) * q2d * q3d -
+                        cos(q3) * q2d * q3d - q3 * cos(q3) * q2dd) * N.z)
+    assert v3.dt(A) == (q2dd * A.x + (2 * q3d**2 + q3 * q3dd) * N.x + (q3dd -
+                        q3 * q3d**2) * N.y + (q3 * sin(q3) * q2d * q3d -
+                        cos(q3) * q2d * q3d - q3 * cos(q3) * q2dd) * N.z)
+    assert (v3.dt(B) - (q2dd*A.x - q3*cos(q3)*q2d**2*A.y + (2*q3d**2 +
+        q3*q3dd)*N.x + (q3dd - q3*q3d**2)*N.y + (2*q3*sin(q3)*q2d*q3d -
+        2*cos(q3)*q2d*q3d - q3*cos(q3)*q2dd)*N.z)).express(B).simplify() == 0
+    assert v4.dt(N) == (q2dd * A.x + q3d * (q2d + q3d) * A.y + q3dd * B.x +
+                        (q3d**2 + q3 * q3dd) * N.x + q3dd * N.y + (q3 *
+                        sin(q3) * q2d * q3d - cos(q3) * q2d * q3d - q3 *
+                        cos(q3) * q2dd) * N.z)
+    assert v4.dt(A) == (q2dd * A.x + q3dd * B.x + (2 * q3d**2 + q3 * q3dd) *
+                        N.x + (q3dd - q3 * q3d**2) * N.y + (q3 * sin(q3) *
+                        q2d * q3d - cos(q3) * q2d * q3d - q3 * cos(q3) *
+                        q2dd) * N.z)
+    assert (v4.dt(B) - (q2dd*A.x - q3*cos(q3)*q2d**2*A.y + q3dd*B.x +
+                        (2*q3d**2 + q3*q3dd)*N.x + (q3dd - q3*q3d**2)*N.y +
+                        (2*q3*sin(q3)*q2d*q3d - 2*cos(q3)*q2d*q3d -
+                         q3*cos(q3)*q2dd)*N.z)).express(B).simplify() == 0
+    assert v5.dt(B) == q1d*A.x + (q3*q2d + q2d)*A.y + (-q2*q2d + q3d)*A.z
+    assert v5.dt(A) == q1d*A.x + q2d*A.y + q3d*A.z
+    assert v5.dt(N) == (-q2*q3d + q1d)*A.x + (q1*q3d + q2d)*A.y + q3d*A.z
+    assert v3.diff(q1d, N) == 0
+    assert v3.diff(q2d, N) == A.x - q3 * cos(q3) * N.z
+    assert v3.diff(q3d, N) == q3 * N.x + N.y
+    assert v3.diff(q1d, A) == 0
+    assert v3.diff(q2d, A) == A.x - q3 * cos(q3) * N.z
+    assert v3.diff(q3d, A) == q3 * N.x + N.y
+    assert v3.diff(q1d, B) == 0
+    assert v3.diff(q2d, B) == A.x - q3 * cos(q3) * N.z
+    assert v3.diff(q3d, B) == q3 * N.x + N.y
+    assert v4.diff(q1d, N) == 0
+    assert v4.diff(q2d, N) == A.x - q3 * cos(q3) * N.z
+    assert v4.diff(q3d, N) == B.x + q3 * N.x + N.y
+    assert v4.diff(q1d, A) == 0
+    assert v4.diff(q2d, A) == A.x - q3 * cos(q3) * N.z
+    assert v4.diff(q3d, A) == B.x + q3 * N.x + N.y
+    assert v4.diff(q1d, B) == 0
+    assert v4.diff(q2d, B) == A.x - q3 * cos(q3) * N.z
+    assert v4.diff(q3d, B) == B.x + q3 * N.x + N.y
+
+    # diff() should only express vector components in the derivative frame if
+    # the orientation of the component's frame depends on the variable
+    v6 = q2**2*N.y + q2**2*A.y + q2**2*B.y
+    # already expressed in N
+    n_measy = 2*q2
+    # A_C_N does not depend on q2, so don't express in N
+    a_measy = 2*q2
+    # B_C_N depends on q2, so express in N
+    b_measx = (q2**2*B.y).dot(N.x).diff(q2)
+    b_measy = (q2**2*B.y).dot(N.y).diff(q2)
+    b_measz = (q2**2*B.y).dot(N.z).diff(q2)
+    n_comp, a_comp = v6.diff(q2, N).args
+    assert len(v6.diff(q2, N).args) == 2  # only N and A parts
+    assert n_comp[1] == N
+    assert a_comp[1] == A
+    assert n_comp[0] == Matrix([b_measx, b_measy + n_measy, b_measz])
+    assert a_comp[0] == Matrix([0, a_measy, 0])
+
+
+def test_vector_var_in_dcm():
+
+    N = ReferenceFrame('N')
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    u1, u2, u3, u4 = dynamicsymbols('u1 u2 u3 u4')
+
+    v = u1 * u2 * A.x + u3 * N.y + u4**2 * N.z
+
+    assert v.diff(u1, N, var_in_dcm=False) == u2 * A.x
+    assert v.diff(u1, A, var_in_dcm=False) == u2 * A.x
+    assert v.diff(u3, N, var_in_dcm=False) == N.y
+    assert v.diff(u3, A, var_in_dcm=False) == N.y
+    assert v.diff(u3, B, var_in_dcm=False) == N.y
+    assert v.diff(u4, N, var_in_dcm=False) == 2 * u4 * N.z
+
+    raises(ValueError, lambda: v.diff(u1, N))
+
+
+def test_vector_simplify():
+    x, y, z, k, n, m, w, f, s, A = symbols('x, y, z, k, n, m, w, f, s, A')
+    N = ReferenceFrame('N')
+
+    test1 = (1 / x + 1 / y) * N.x
+    assert (test1 & N.x) != (x + y) / (x * y)
+    test1 = test1.simplify()
+    assert (test1 & N.x) == (x + y) / (x * y)
+
+    test2 = (A**2 * s**4 / (4 * pi * k * m**3)) * N.x
+    test2 = test2.simplify()
+    assert (test2 & N.x) == (A**2 * s**4 / (4 * pi * k * m**3))
+
+    test3 = ((4 + 4 * x - 2 * (2 + 2 * x)) / (2 + 2 * x)) * N.x
+    test3 = test3.simplify()
+    assert (test3 & N.x) == 0
+
+    test4 = ((-4 * x * y**2 - 2 * y**3 - 2 * x**2 * y) / (x + y)**2) * N.x
+    test4 = test4.simplify()
+    assert (test4 & N.x) == -2 * y
+
+
+def test_vector_evalf():
+    a, b = symbols('a b')
+    v = pi * A.x
+    assert v.evalf(2) == Float('3.1416', 2) * A.x
+    v = pi * A.x + 5 * a * A.y - b * A.z
+    assert v.evalf(3) == Float('3.1416', 3) * A.x + Float('5', 3) * a * A.y - b * A.z
+    assert v.evalf(5, subs={a: 1.234, b:5.8973}) == Float('3.1415926536', 5) * A.x + Float('6.17', 5) * A.y - Float('5.8973', 5) * A.z
+
+
+def test_vector_angle():
+    A = ReferenceFrame('A')
+    v1 = A.x + A.y
+    v2 = A.z
+    assert v1.angle_between(v2) == pi/2
+    B = ReferenceFrame('B')
+    B.orient_axis(A, A.x, pi)
+    v3 = A.x
+    v4 = B.x
+    assert v3.angle_between(v4) == 0
+
+
+def test_vector_xreplace():
+    x, y, z = symbols('x y z')
+    v = x**2 * A.x + x*y * A.y + x*y*z * A.z
+    assert v.xreplace({x : cos(x)}) == cos(x)**2 * A.x + y*cos(x) * A.y + y*z*cos(x) * A.z
+    assert v.xreplace({x*y : pi}) == x**2 * A.x + pi * A.y + x*y*z * A.z
+    assert v.xreplace({x*y*z : 1}) == x**2*A.x + x*y*A.y + A.z
+    assert v.xreplace({x:1, z:0}) == A.x + y * A.y
+    raises(TypeError, lambda: v.xreplace())
+    raises(TypeError, lambda: v.xreplace([x, y]))
+
+def test_issue_23366():
+    u1 = dynamicsymbols('u1')
+    N = ReferenceFrame('N')
+    N_v_A = u1*N.x
+    raises(VectorTypeError, lambda: N_v_A.diff(N, u1))
+
+
+def test_vector_outer():
+    a, b, c, d, e, f = symbols('a, b, c, d, e, f')
+    N = ReferenceFrame('N')
+    v1 = a*N.x + b*N.y + c*N.z
+    v2 = d*N.x + e*N.y + f*N.z
+    v1v2 = Matrix([[a*d, a*e, a*f],
+                   [b*d, b*e, b*f],
+                   [c*d, c*e, c*f]])
+    assert v1.outer(v2).to_matrix(N) == v1v2
+    assert (v1 | v2).to_matrix(N) == v1v2
+    v2v1 = Matrix([[d*a, d*b, d*c],
+                   [e*a, e*b, e*c],
+                   [f*a, f*b, f*c]])
+    assert v2.outer(v1).to_matrix(N) == v2v1
+    assert (v2 | v1).to_matrix(N) == v2v1
+
+
+def test_overloaded_operators():
+    a, b, c, d, e, f = symbols('a, b, c, d, e, f')
+    N = ReferenceFrame('N')
+    v1 = a*N.x + b*N.y + c*N.z
+    v2 = d*N.x + e*N.y + f*N.z
+
+    assert v1 + v2 == v2 + v1
+    assert v1 - v2 == -v2 + v1
+    assert v1 & v2 == v2 & v1
+    assert v1 ^ v2 == v1.cross(v2)
+    assert v2 ^ v1 == v2.cross(v1)

venv/lib/python3.11/site-packages/sympy/physics/vector/vector.py

@@ -0,0 +1,806 @@
+from sympy import (S, sympify, expand, sqrt, Add, zeros, acos,
+                   ImmutableMatrix as Matrix, simplify)
+from sympy.simplify.trigsimp import trigsimp
+from sympy.printing.defaults import Printable
+from sympy.utilities.misc import filldedent
+from sympy.core.evalf import EvalfMixin
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+__all__ = ['Vector']
+
+
+class Vector(Printable, EvalfMixin):
+    """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.
+
+    Attributes
+    ==========
+
+    simp : Boolean
+        Let certain methods use trigsimp on their outputs
+
+    """
+
+    simp = False
+    is_number = False
+
+    def __init__(self, inlist):
+        """This is the constructor for the Vector class. You should not be
+        calling this, it should only be used by other functions. You should be
+        treating Vectors like you would with if you were doing the math by
+        hand, and getting the first 3 from the standard basis vectors from a
+        ReferenceFrame.
+
+        The only exception is to create a zero vector:
+        zv = Vector(0)
+
+        """
+
+        self.args = []
+        if inlist == 0:
+            inlist = []
+        if isinstance(inlist, dict):
+            d = inlist
+        else:
+            d = {}
+            for inp in inlist:
+                if inp[1] in d:
+                    d[inp[1]] += inp[0]
+                else:
+                    d[inp[1]] = inp[0]
+
+        for k, v in d.items():
+            if v != Matrix([0, 0, 0]):
+                self.args.append((v, k))
+
+    @property
+    def func(self):
+        """Returns the class Vector. """
+        return Vector
+
+    def __hash__(self):
+        return hash(tuple(self.args))
+
+    def __add__(self, other):
+        """The add operator for Vector. """
+        if other == 0:
+            return self
+        other = _check_vector(other)
+        return Vector(self.args + other.args)
+
+    def dot(self, other):
+        """Dot product of two vectors.
+
+        Returns a scalar, the dot product of the two Vectors
+
+        Parameters
+        ==========
+
+        other : Vector
+            The Vector which we are dotting with
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, dot
+        >>> from sympy import symbols
+        >>> q1 = symbols('q1')
+        >>> N = ReferenceFrame('N')
+        >>> dot(N.x, N.x)
+        1
+        >>> dot(N.x, N.y)
+        0
+        >>> A = N.orientnew('A', 'Axis', [q1, N.x])
+        >>> dot(N.y, A.y)
+        cos(q1)
+
+        """
+
+        from sympy.physics.vector.dyadic import Dyadic, _check_dyadic
+        if isinstance(other, Dyadic):
+            other = _check_dyadic(other)
+            ol = Vector(0)
+            for v in other.args:
+                ol += v[0] * v[2] * (v[1].dot(self))
+            return ol
+        other = _check_vector(other)
+        out = S.Zero
+        for v1 in self.args:
+            for v2 in other.args:
+                out += ((v2[0].T) * (v2[1].dcm(v1[1])) * (v1[0]))[0]
+        if Vector.simp:
+            return trigsimp(out, recursive=True)
+        else:
+            return out
+
+    def __truediv__(self, other):
+        """This uses mul and inputs self and 1 divided by other. """
+        return self.__mul__(S.One / other)
+
+    def __eq__(self, other):
+        """Tests for equality.
+
+        It is very import to note that this is only as good as the SymPy
+        equality test; False does not always mean they are not equivalent
+        Vectors.
+        If other is 0, and self is empty, returns True.
+        If other is 0 and self is not empty, returns False.
+        If none of the above, only accepts other as a Vector.
+
+        """
+
+        if other == 0:
+            other = Vector(0)
+        try:
+            other = _check_vector(other)
+        except TypeError:
+            return False
+        if (self.args == []) and (other.args == []):
+            return True
+        elif (self.args == []) or (other.args == []):
+            return False
+
+        frame = self.args[0][1]
+        for v in frame:
+            if expand((self - other).dot(v)) != 0:
+                return False
+        return True
+
+    def __mul__(self, other):
+        """Multiplies the Vector by a sympifyable expression.
+
+        Parameters
+        ==========
+
+        other : Sympifyable
+            The scalar to multiply this Vector with
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> from sympy import Symbol
+        >>> N = ReferenceFrame('N')
+        >>> b = Symbol('b')
+        >>> V = 10 * b * N.x
+        >>> print(V)
+        10*b*N.x
+
+        """
+
+        newlist = list(self.args)
+        other = sympify(other)
+        for i in range(len(newlist)):
+            newlist[i] = (other * newlist[i][0], newlist[i][1])
+        return Vector(newlist)
+
+    def __neg__(self):
+        return self * -1
+
+    def outer(self, other):
+        """Outer product between two Vectors.
+
+        A rank increasing operation, which returns a Dyadic from two Vectors
+
+        Parameters
+        ==========
+
+        other : Vector
+            The Vector to take the outer product with
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, outer
+        >>> N = ReferenceFrame('N')
+        >>> outer(N.x, N.x)
+        (N.x|N.x)
+
+        """
+
+        from sympy.physics.vector.dyadic import Dyadic
+        other = _check_vector(other)
+        ol = Dyadic(0)
+        for v in self.args:
+            for v2 in other.args:
+                # it looks this way because if we are in the same frame and
+                # use the enumerate function on the same frame in a nested
+                # fashion, then bad things happen
+                ol += Dyadic([(v[0][0] * v2[0][0], v[1].x, v2[1].x)])
+                ol += Dyadic([(v[0][0] * v2[0][1], v[1].x, v2[1].y)])
+                ol += Dyadic([(v[0][0] * v2[0][2], v[1].x, v2[1].z)])
+                ol += Dyadic([(v[0][1] * v2[0][0], v[1].y, v2[1].x)])
+                ol += Dyadic([(v[0][1] * v2[0][1], v[1].y, v2[1].y)])
+                ol += Dyadic([(v[0][1] * v2[0][2], v[1].y, v2[1].z)])
+                ol += Dyadic([(v[0][2] * v2[0][0], v[1].z, v2[1].x)])
+                ol += Dyadic([(v[0][2] * v2[0][1], v[1].z, v2[1].y)])
+                ol += Dyadic([(v[0][2] * v2[0][2], v[1].z, v2[1].z)])
+        return ol
+
+    def _latex(self, printer):
+        """Latex Printing method. """
+
+        ar = self.args  # just to shorten things
+        if len(ar) == 0:
+            return str(0)
+        ol = []  # output list, to be concatenated to a string
+        for v in ar:
+            for j in 0, 1, 2:
+                # if the coef of the basis vector is 1, we skip the 1
+                if v[0][j] == 1:
+                    ol.append(' + ' + v[1].latex_vecs[j])
+                # if the coef of the basis vector is -1, we skip the 1
+                elif v[0][j] == -1:
+                    ol.append(' - ' + v[1].latex_vecs[j])
+                elif v[0][j] != 0:
+                    # If the coefficient of the basis vector is not 1 or -1;
+                    # also, we might wrap it in parentheses, for readability.
+                    arg_str = printer._print(v[0][j])
+                    if isinstance(v[0][j], Add):
+                        arg_str = "(%s)" % arg_str
+                    if arg_str[0] == '-':
+                        arg_str = arg_str[1:]
+                        str_start = ' - '
+                    else:
+                        str_start = ' + '
+                    ol.append(str_start + arg_str + v[1].latex_vecs[j])
+        outstr = ''.join(ol)
+        if outstr.startswith(' + '):
+            outstr = outstr[3:]
+        elif outstr.startswith(' '):
+            outstr = outstr[1:]
+        return outstr
+
+    def _pretty(self, printer):
+        """Pretty Printing method. """
+        from sympy.printing.pretty.stringpict import prettyForm
+
+        terms = []
+
+        def juxtapose(a, b):
+            pa = printer._print(a)
+            pb = printer._print(b)
+            if a.is_Add:
+                pa = prettyForm(*pa.parens())
+            return printer._print_seq([pa, pb], delimiter=' ')
+
+        for M, N in self.args:
+            for i in range(3):
+                if M[i] == 0:
+                    continue
+                elif M[i] == 1:
+                    terms.append(prettyForm(N.pretty_vecs[i]))
+                elif M[i] == -1:
+                    terms.append(prettyForm("-1") * prettyForm(N.pretty_vecs[i]))
+                else:
+                    terms.append(juxtapose(M[i], N.pretty_vecs[i]))
+
+        if terms:
+            pretty_result = prettyForm.__add__(*terms)
+        else:
+            pretty_result = prettyForm("0")
+
+        return pretty_result
+
+    def __rsub__(self, other):
+        return (-1 * self) + other
+
+    def _sympystr(self, printer, order=True):
+        """Printing method. """
+        if not order or len(self.args) == 1:
+            ar = list(self.args)
+        elif len(self.args) == 0:
+            return printer._print(0)
+        else:
+            d = {v[1]: v[0] for v in self.args}
+            keys = sorted(d.keys(), key=lambda x: x.index)
+            ar = []
+            for key in keys:
+                ar.append((d[key], key))
+        ol = []  # output list, to be concatenated to a string
+        for v in ar:
+            for j in 0, 1, 2:
+                # if the coef of the basis vector is 1, we skip the 1
+                if v[0][j] == 1:
+                    ol.append(' + ' + v[1].str_vecs[j])
+                # if the coef of the basis vector is -1, we skip the 1
+                elif v[0][j] == -1:
+                    ol.append(' - ' + v[1].str_vecs[j])
+                elif v[0][j] != 0:
+                    # If the coefficient of the basis vector is not 1 or -1;
+                    # also, we might wrap it in parentheses, for readability.
+                    arg_str = printer._print(v[0][j])
+                    if isinstance(v[0][j], Add):
+                        arg_str = "(%s)" % arg_str
+                    if arg_str[0] == '-':
+                        arg_str = arg_str[1:]
+                        str_start = ' - '
+                    else:
+                        str_start = ' + '
+                    ol.append(str_start + arg_str + '*' + v[1].str_vecs[j])
+        outstr = ''.join(ol)
+        if outstr.startswith(' + '):
+            outstr = outstr[3:]
+        elif outstr.startswith(' '):
+            outstr = outstr[1:]
+        return outstr
+
+    def __sub__(self, other):
+        """The subtraction operator. """
+        return self.__add__(other * -1)
+
+    def cross(self, other):
+        """The cross product operator for two Vectors.
+
+        Returns a Vector, expressed in the same ReferenceFrames as self.
+
+        Parameters
+        ==========
+
+        other : Vector
+            The Vector which we are crossing with
+
+        Examples
+        ========
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.vector import ReferenceFrame, cross
+        >>> q1 = symbols('q1')
+        >>> N = ReferenceFrame('N')
+        >>> cross(N.x, N.y)
+        N.z
+        >>> A = ReferenceFrame('A')
+        >>> A.orient_axis(N, q1, N.x)
+        >>> cross(A.x, N.y)
+        N.z
+        >>> cross(N.y, A.x)
+        - sin(q1)*A.y - cos(q1)*A.z
+
+        """
+
+        from sympy.physics.vector.dyadic import Dyadic, _check_dyadic
+        if isinstance(other, Dyadic):
+            other = _check_dyadic(other)
+            ol = Dyadic(0)
+            for i, v in enumerate(other.args):
+                ol += v[0] * ((self.cross(v[1])).outer(v[2]))
+            return ol
+        other = _check_vector(other)
+        if other.args == []:
+            return Vector(0)
+
+        def _det(mat):
+            """This is needed as a little method for to find the determinant
+            of a list in python; needs to work for a 3x3 list.
+            SymPy's Matrix will not take in Vector, so need a custom function.
+            You should not be calling this.
+
+            """
+
+            return (mat[0][0] * (mat[1][1] * mat[2][2] - mat[1][2] * mat[2][1])
+                    + mat[0][1] * (mat[1][2] * mat[2][0] - mat[1][0] *
+                    mat[2][2]) + mat[0][2] * (mat[1][0] * mat[2][1] -
+                    mat[1][1] * mat[2][0]))
+
+        outlist = []
+        ar = other.args  # For brevity
+        for v in ar:
+            tempx = v[1].x
+            tempy = v[1].y
+            tempz = v[1].z
+            tempm = ([[tempx, tempy, tempz],
+                      [self.dot(tempx), self.dot(tempy), self.dot(tempz)],
+                      [Vector([v]).dot(tempx), Vector([v]).dot(tempy),
+                       Vector([v]).dot(tempz)]])
+            outlist += _det(tempm).args
+        return Vector(outlist)
+
+    __radd__ = __add__
+    __rmul__ = __mul__
+
+    def separate(self):
+        """
+        The constituents of this vector in different reference frames,
+        as per its definition.
+
+        Returns a dict mapping each ReferenceFrame to the corresponding
+        constituent Vector.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> R1 = ReferenceFrame('R1')
+        >>> R2 = ReferenceFrame('R2')
+        >>> v = R1.x + R2.x
+        >>> v.separate() == {R1: R1.x, R2: R2.x}
+        True
+
+        """
+
+        components = {}
+        for x in self.args:
+            components[x[1]] = Vector([x])
+        return components
+
+    def __and__(self, other):
+        return self.dot(other)
+    __and__.__doc__ = dot.__doc__
+    __rand__ = __and__
+
+    def __xor__(self, other):
+        return self.cross(other)
+    __xor__.__doc__ = cross.__doc__
+
+    def __or__(self, other):
+        return self.outer(other)
+    __or__.__doc__ = outer.__doc__
+
+    def diff(self, var, frame, var_in_dcm=True):
+        """Returns the partial derivative of the vector with respect to a
+        variable in the provided reference frame.
+
+        Parameters
+        ==========
+        var : Symbol
+            What the partial derivative is taken with respect to.
+        frame : ReferenceFrame
+            The reference frame that the partial derivative is taken in.
+        var_in_dcm : boolean
+            If true, the differentiation algorithm assumes that the variable
+            may be present in any of the direction cosine matrices that relate
+            the frame to the frames of any component of the vector. But if it
+            is known that the variable is not present in the direction cosine
+            matrices, false can be set to skip full reexpression in the desired
+            frame.
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol
+        >>> from sympy.physics.vector import dynamicsymbols, ReferenceFrame
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> t = Symbol('t')
+        >>> q1 = dynamicsymbols('q1')
+        >>> N = ReferenceFrame('N')
+        >>> A = N.orientnew('A', 'Axis', [q1, N.y])
+        >>> A.x.diff(t, N)
+        - sin(q1)*q1'*N.x - cos(q1)*q1'*N.z
+        >>> A.x.diff(t, N).express(A).simplify()
+        - q1'*A.z
+        >>> B = ReferenceFrame('B')
+        >>> u1, u2 = dynamicsymbols('u1, u2')
+        >>> v = u1 * A.x + u2 * B.y
+        >>> v.diff(u2, N, var_in_dcm=False)
+        B.y
+
+        """
+
+        from sympy.physics.vector.frame import _check_frame
+
+        _check_frame(frame)
+        var = sympify(var)
+
+        inlist = []
+
+        for vector_component in self.args:
+            measure_number = vector_component[0]
+            component_frame = vector_component[1]
+            if component_frame == frame:
+                inlist += [(measure_number.diff(var), frame)]
+            else:
+                # If the direction cosine matrix relating the component frame
+                # with the derivative frame does not contain the variable.
+                if not var_in_dcm or (frame.dcm(component_frame).diff(var) ==
+                                      zeros(3, 3)):
+                    inlist += [(measure_number.diff(var), component_frame)]
+                else:  # else express in the frame
+                    reexp_vec_comp = Vector([vector_component]).express(frame)
+                    deriv = reexp_vec_comp.args[0][0].diff(var)
+                    inlist += Vector([(deriv, frame)]).args
+
+        return Vector(inlist)
+
+    def express(self, otherframe, variables=False):
+        """
+        Returns a Vector equivalent to this one, expressed in otherframe.
+        Uses the global express method.
+
+        Parameters
+        ==========
+
+        otherframe : ReferenceFrame
+            The frame for this Vector to be described in
+
+        variables : boolean
+            If True, the coordinate symbols(if present) in this Vector
+            are re-expressed in terms otherframe
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> q1 = dynamicsymbols('q1')
+        >>> N = ReferenceFrame('N')
+        >>> A = N.orientnew('A', 'Axis', [q1, N.y])
+        >>> A.x.express(N)
+        cos(q1)*N.x - sin(q1)*N.z
+
+        """
+        from sympy.physics.vector import express
+        return express(self, otherframe, variables=variables)
+
+    def to_matrix(self, reference_frame):
+        """Returns the matrix form of the vector with respect to the given
+        frame.
+
+        Parameters
+        ----------
+        reference_frame : ReferenceFrame
+            The reference frame that the rows of the matrix correspond to.
+
+        Returns
+        -------
+        matrix : ImmutableMatrix, shape(3,1)
+            The matrix that gives the 1D vector.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> a, b, c = symbols('a, b, c')
+        >>> N = ReferenceFrame('N')
+        >>> vector = a * N.x + b * N.y + c * N.z
+        >>> vector.to_matrix(N)
+        Matrix([
+        [a],
+        [b],
+        [c]])
+        >>> beta = symbols('beta')
+        >>> A = N.orientnew('A', 'Axis', (beta, N.x))
+        >>> vector.to_matrix(A)
+        Matrix([
+        [                         a],
+        [ b*cos(beta) + c*sin(beta)],
+        [-b*sin(beta) + c*cos(beta)]])
+
+        """
+
+        return Matrix([self.dot(unit_vec) for unit_vec in
+                       reference_frame]).reshape(3, 1)
+
+    def doit(self, **hints):
+        """Calls .doit() on each term in the Vector"""
+        d = {}
+        for v in self.args:
+            d[v[1]] = v[0].applyfunc(lambda x: x.doit(**hints))
+        return Vector(d)
+
+    def dt(self, otherframe):
+        """
+        Returns a Vector which is the time derivative of
+        the self Vector, taken in frame otherframe.
+
+        Calls the global time_derivative method
+
+        Parameters
+        ==========
+
+        otherframe : ReferenceFrame
+            The frame to calculate the time derivative in
+
+        """
+        from sympy.physics.vector import time_derivative
+        return time_derivative(self, otherframe)
+
+    def simplify(self):
+        """Returns a simplified Vector."""
+        d = {}
+        for v in self.args:
+            d[v[1]] = simplify(v[0])
+        return Vector(d)
+
+    def subs(self, *args, **kwargs):
+        """Substitution on the Vector.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> from sympy import Symbol
+        >>> N = ReferenceFrame('N')
+        >>> s = Symbol('s')
+        >>> a = N.x * s
+        >>> a.subs({s: 2})
+        2*N.x
+
+        """
+
+        d = {}
+        for v in self.args:
+            d[v[1]] = v[0].subs(*args, **kwargs)
+        return Vector(d)
+
+    def magnitude(self):
+        """Returns the magnitude (Euclidean norm) of self.
+
+        Warnings
+        ========
+
+        Python ignores the leading negative sign so that might
+        give wrong results.
+        ``-A.x.magnitude()`` would be treated as ``-(A.x.magnitude())``,
+        instead of ``(-A.x).magnitude()``.
+
+        """
+        return sqrt(self.dot(self))
+
+    def normalize(self):
+        """Returns a Vector of magnitude 1, codirectional with self."""
+        return Vector(self.args + []) / self.magnitude()
+
+    def applyfunc(self, f):
+        """Apply a function to each component of a vector."""
+        if not callable(f):
+            raise TypeError("`f` must be callable.")
+
+        d = {}
+        for v in self.args:
+            d[v[1]] = v[0].applyfunc(f)
+        return Vector(d)
+
+    def angle_between(self, vec):
+        """
+        Returns the smallest angle between Vector 'vec' and self.
+
+        Parameter
+        =========
+
+        vec : Vector
+            The Vector between which angle is needed.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> A = ReferenceFrame("A")
+        >>> v1 = A.x
+        >>> v2 = A.y
+        >>> v1.angle_between(v2)
+        pi/2
+
+        >>> v3 = A.x + A.y + A.z
+        >>> v1.angle_between(v3)
+        acos(sqrt(3)/3)
+
+        Warnings
+        ========
+
+        Python ignores the leading negative sign so that might give wrong
+        results. ``-A.x.angle_between()`` would be treated as
+        ``-(A.x.angle_between())``, instead of ``(-A.x).angle_between()``.
+
+        """
+
+        vec1 = self.normalize()
+        vec2 = vec.normalize()
+        angle = acos(vec1.dot(vec2))
+        return angle
+
+    def free_symbols(self, reference_frame):
+        """Returns the free symbols in the measure numbers of the vector
+        expressed in the given reference frame.
+
+        Parameters
+        ==========
+        reference_frame : ReferenceFrame
+            The frame with respect to which the free symbols of the given
+            vector is to be determined.
+
+        Returns
+        =======
+        set of Symbol
+            set of symbols present in the measure numbers of
+            ``reference_frame``.
+
+        """
+
+        return self.to_matrix(reference_frame).free_symbols
+
+    def free_dynamicsymbols(self, reference_frame):
+        """Returns the free dynamic symbols (functions of time ``t``) in the
+        measure numbers of the vector expressed in the given reference frame.
+
+        Parameters
+        ==========
+        reference_frame : ReferenceFrame
+            The frame with respect to which the free dynamic symbols of the
+            given vector is to be determined.
+
+        Returns
+        =======
+        set
+            Set of functions of time ``t``, e.g.
+            ``Function('f')(me.dynamicsymbols._t)``.
+
+        """
+        # TODO : Circular dependency if imported at top. Should move
+        # find_dynamicsymbols into physics.vector.functions.
+        from sympy.physics.mechanics.functions import find_dynamicsymbols
+
+        return find_dynamicsymbols(self, reference_frame=reference_frame)
+
+    def _eval_evalf(self, prec):
+        if not self.args:
+            return self
+        new_args = []
+        dps = prec_to_dps(prec)
+        for mat, frame in self.args:
+            new_args.append([mat.evalf(n=dps), frame])
+        return Vector(new_args)
+
+    def xreplace(self, rule):
+        """Replace occurrences of objects within the measure numbers of the
+        vector.
+
+        Parameters
+        ==========
+
+        rule : dict-like
+            Expresses a replacement rule.
+
+        Returns
+        =======
+
+        Vector
+            Result of the replacement.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, pi
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> A = ReferenceFrame('A')
+        >>> x, y, z = symbols('x y z')
+        >>> ((1 + x*y) * A.x).xreplace({x: pi})
+        (pi*y + 1)*A.x
+        >>> ((1 + x*y) * A.x).xreplace({x: pi, y: 2})
+        (1 + 2*pi)*A.x
+
+        Replacements occur only if an entire node in the expression tree is
+        matched:
+
+        >>> ((x*y + z) * A.x).xreplace({x*y: pi})
+        (z + pi)*A.x
+        >>> ((x*y*z) * A.x).xreplace({x*y: pi})
+        x*y*z*A.x
+
+        """
+
+        new_args = []
+        for mat, frame in self.args:
+            mat = mat.xreplace(rule)
+            new_args.append([mat, frame])
+        return Vector(new_args)
+
+
+class VectorTypeError(TypeError):
+
+    def __init__(self, other, want):
+        msg = filldedent("Expected an instance of %s, but received object "
+                         "'%s' of %s." % (type(want), other, type(other)))
+        super().__init__(msg)
+
+
+def _check_vector(other):
+    if not isinstance(other, Vector):
+        raise TypeError('A Vector must be supplied')
+    return other

venv/lib/python3.11/site-packages/sympy/physics/wigner.py

@@ -0,0 +1,1213 @@
+# -*- coding: utf-8 -*-
+r"""
+Wigner, Clebsch-Gordan, Racah, and Gaunt coefficients
+
+Collection of functions for calculating Wigner 3j, 6j, 9j,
+Clebsch-Gordan, Racah as well as Gaunt coefficients exactly, all
+evaluating to a rational number times the square root of a rational
+number [Rasch03]_.
+
+Please see the description of the individual functions for further
+details and examples.
+
+References
+==========
+
+.. [Regge58] 'Symmetry Properties of Clebsch-Gordan Coefficients',
+  T. Regge, Nuovo Cimento, Volume 10, pp. 544 (1958)
+.. [Regge59] 'Symmetry Properties of Racah Coefficients',
+  T. Regge, Nuovo Cimento, Volume 11, pp. 116 (1959)
+.. [Edmonds74] A. R. Edmonds. Angular momentum in quantum mechanics.
+  Investigations in physics, 4.; Investigations in physics, no. 4.
+  Princeton, N.J., Princeton University Press, 1957.
+.. [Rasch03] J. Rasch and A. C. H. Yu, 'Efficient Storage Scheme for
+  Pre-calculated Wigner 3j, 6j and Gaunt Coefficients', SIAM
+  J. Sci. Comput. Volume 25, Issue 4, pp. 1416-1428 (2003)
+.. [Liberatodebrito82] 'FORTRAN program for the integral of three
+  spherical harmonics', A. Liberato de Brito,
+  Comput. Phys. Commun., Volume 25, pp. 81-85 (1982)
+.. [Homeier96] 'Some Properties of the Coupling Coefficients of Real
+  Spherical Harmonics and Their Relation to Gaunt Coefficients',
+  H. H. H. Homeier and E. O. Steinborn J. Mol. Struct., Volume 368,
+  pp. 31-37 (1996)
+
+Credits and Copyright
+=====================
+
+This code was taken from Sage with the permission of all authors:
+
+https://groups.google.com/forum/#!topic/sage-devel/M4NZdu-7O38
+
+Authors
+=======
+
+- Jens Rasch (2009-03-24): initial version for Sage
+
+- Jens Rasch (2009-05-31): updated to sage-4.0
+
+- Oscar Gerardo Lazo Arjona (2017-06-18): added Wigner D matrices
+
+- Phil Adam LeMaitre (2022-09-19): added real Gaunt coefficient
+
+Copyright (C) 2008 Jens Rasch <jyr2000@gmail.com>
+
+"""
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.numbers import int_valued
+from sympy.core.function import Function
+from sympy.core.numbers import (Float, I, Integer, pi, Rational)
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import (binomial, factorial)
+from sympy.functions.elementary.complexes import re
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.spherical_harmonics import Ynm
+from sympy.matrices.dense import zeros
+from sympy.matrices.immutable import ImmutableMatrix
+from sympy.utilities.misc import as_int
+
+# This list of precomputed factorials is needed to massively
+# accelerate future calculations of the various coefficients
+_Factlist = [1]
+
+
+def _calc_factlist(nn):
+    r"""
+    Function calculates a list of precomputed factorials in order to
+    massively accelerate future calculations of the various
+    coefficients.
+
+    Parameters
+    ==========
+
+    nn : integer
+        Highest factorial to be computed.
+
+    Returns
+    =======
+
+    list of integers :
+        The list of precomputed factorials.
+
+    Examples
+    ========
+
+    Calculate list of factorials::
+
+        sage: from sage.functions.wigner import _calc_factlist
+        sage: _calc_factlist(10)
+        [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]
+    """
+    if nn >= len(_Factlist):
+        for ii in range(len(_Factlist), int(nn + 1)):
+            _Factlist.append(_Factlist[ii - 1] * ii)
+    return _Factlist[:int(nn) + 1]
+
+
+def _int_or_halfint(value):
+    """return Python int unless value is half-int (then return float)"""
+    if isinstance(value, int):
+        return value
+    elif type(value) is float:
+        if value.is_integer():
+            return int(value)  # an int
+        if (2*value).is_integer():
+            return value  # a float
+    elif isinstance(value, Rational):
+        if value.q == 2:
+            return value.p/value.q  # a float
+        elif value.q == 1:
+            return value.p  # an int
+    elif isinstance(value, Float):
+        return _int_or_halfint(float(value))
+    raise ValueError("expecting integer or half-integer, got %s" % value)
+
+
+def wigner_3j(j_1, j_2, j_3, m_1, m_2, m_3):
+    r"""
+    Calculate the Wigner 3j symbol `\operatorname{Wigner3j}(j_1,j_2,j_3,m_1,m_2,m_3)`.
+
+    Parameters
+    ==========
+
+    j_1, j_2, j_3, m_1, m_2, m_3 :
+        Integer or half integer.
+
+    Returns
+    =======
+
+    Rational number times the square root of a rational number.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.wigner import wigner_3j
+    >>> wigner_3j(2, 6, 4, 0, 0, 0)
+    sqrt(715)/143
+    >>> wigner_3j(2, 6, 4, 0, 0, 1)
+    0
+
+    It is an error to have arguments that are not integer or half
+    integer values::
+
+        sage: wigner_3j(2.1, 6, 4, 0, 0, 0)
+        Traceback (most recent call last):
+        ...
+        ValueError: j values must be integer or half integer
+        sage: wigner_3j(2, 6, 4, 1, 0, -1.1)
+        Traceback (most recent call last):
+        ...
+        ValueError: m values must be integer or half integer
+
+    Notes
+    =====
+
+    The Wigner 3j symbol obeys the following symmetry rules:
+
+    - invariant under any permutation of the columns (with the
+      exception of a sign change where `J:=j_1+j_2+j_3`):
+
+      .. math::
+
+         \begin{aligned}
+         \operatorname{Wigner3j}(j_1,j_2,j_3,m_1,m_2,m_3)
+          &=\operatorname{Wigner3j}(j_3,j_1,j_2,m_3,m_1,m_2) \\
+          &=\operatorname{Wigner3j}(j_2,j_3,j_1,m_2,m_3,m_1) \\
+          &=(-1)^J \operatorname{Wigner3j}(j_3,j_2,j_1,m_3,m_2,m_1) \\
+          &=(-1)^J \operatorname{Wigner3j}(j_1,j_3,j_2,m_1,m_3,m_2) \\
+          &=(-1)^J \operatorname{Wigner3j}(j_2,j_1,j_3,m_2,m_1,m_3)
+         \end{aligned}
+
+    - invariant under space inflection, i.e.
+
+      .. math::
+
+         \operatorname{Wigner3j}(j_1,j_2,j_3,m_1,m_2,m_3)
+         =(-1)^J \operatorname{Wigner3j}(j_1,j_2,j_3,-m_1,-m_2,-m_3)
+
+    - symmetric with respect to the 72 additional symmetries based on
+      the work by [Regge58]_
+
+    - zero for `j_1`, `j_2`, `j_3` not fulfilling triangle relation
+
+    - zero for `m_1 + m_2 + m_3 \neq 0`
+
+    - zero for violating any one of the conditions
+         `m_1  \in \{-|j_1|, \ldots, |j_1|\}`,
+         `m_2  \in \{-|j_2|, \ldots, |j_2|\}`,
+         `m_3  \in \{-|j_3|, \ldots, |j_3|\}`
+
+    Algorithm
+    =========
+
+    This function uses the algorithm of [Edmonds74]_ to calculate the
+    value of the 3j symbol exactly. Note that the formula contains
+    alternating sums over large factorials and is therefore unsuitable
+    for finite precision arithmetic and only useful for a computer
+    algebra system [Rasch03]_.
+
+    Authors
+    =======
+
+    - Jens Rasch (2009-03-24): initial version
+    """
+
+    j_1, j_2, j_3, m_1, m_2, m_3 = \
+        map(_int_or_halfint, map(sympify,
+            [j_1, j_2, j_3, m_1, m_2, m_3]))
+
+    if m_1 + m_2 + m_3 != 0:
+        return S.Zero
+    a1 = j_1 + j_2 - j_3
+    if a1 < 0:
+        return S.Zero
+    a2 = j_1 - j_2 + j_3
+    if a2 < 0:
+        return S.Zero
+    a3 = -j_1 + j_2 + j_3
+    if a3 < 0:
+        return S.Zero
+    if (abs(m_1) > j_1) or (abs(m_2) > j_2) or (abs(m_3) > j_3):
+        return S.Zero
+    if not (int_valued(j_1 - m_1) and \
+            int_valued(j_2 - m_2) and \
+            int_valued(j_3 - m_3)):
+        return S.Zero
+
+    maxfact = max(j_1 + j_2 + j_3 + 1, j_1 + abs(m_1), j_2 + abs(m_2),
+                  j_3 + abs(m_3))
+    _calc_factlist(int(maxfact))
+
+    argsqrt = Integer(_Factlist[int(j_1 + j_2 - j_3)] *
+                     _Factlist[int(j_1 - j_2 + j_3)] *
+                     _Factlist[int(-j_1 + j_2 + j_3)] *
+                     _Factlist[int(j_1 - m_1)] *
+                     _Factlist[int(j_1 + m_1)] *
+                     _Factlist[int(j_2 - m_2)] *
+                     _Factlist[int(j_2 + m_2)] *
+                     _Factlist[int(j_3 - m_3)] *
+                     _Factlist[int(j_3 + m_3)]) / \
+        _Factlist[int(j_1 + j_2 + j_3 + 1)]
+
+    ressqrt = sqrt(argsqrt)
+    if ressqrt.is_complex or ressqrt.is_infinite:
+        ressqrt = ressqrt.as_real_imag()[0]
+
+    imin = max(-j_3 + j_1 + m_2, -j_3 + j_2 - m_1, 0)
+    imax = min(j_2 + m_2, j_1 - m_1, j_1 + j_2 - j_3)
+    sumres = 0
+    for ii in range(int(imin), int(imax) + 1):
+        den = _Factlist[ii] * \
+            _Factlist[int(ii + j_3 - j_1 - m_2)] * \
+            _Factlist[int(j_2 + m_2 - ii)] * \
+            _Factlist[int(j_1 - ii - m_1)] * \
+            _Factlist[int(ii + j_3 - j_2 + m_1)] * \
+            _Factlist[int(j_1 + j_2 - j_3 - ii)]
+        sumres = sumres + Integer((-1) ** ii) / den
+
+    prefid = Integer((-1) ** int(j_1 - j_2 - m_3))
+    res = ressqrt * sumres * prefid
+    return res
+
+
+def clebsch_gordan(j_1, j_2, j_3, m_1, m_2, m_3):
+    r"""
+    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]_.
+
+    Parameters
+    ==========
+
+    j_1, j_2, j_3, m_1, m_2, m_3 :
+        Integer or half integer.
+
+    Returns
+    =======
+
+    Rational number times the square root of a rational number.
+
+    Examples
+    ========
+
+    >>> from sympy import S
+    >>> from sympy.physics.wigner import clebsch_gordan
+    >>> clebsch_gordan(S(3)/2, S(1)/2, 2, S(3)/2, S(1)/2, 2)
+    1
+    >>> clebsch_gordan(S(3)/2, S(1)/2, 1, S(3)/2, -S(1)/2, 1)
+    sqrt(3)/2
+    >>> clebsch_gordan(S(3)/2, S(1)/2, 1, -S(1)/2, S(1)/2, 0)
+    -sqrt(2)/2
+
+    Notes
+    =====
+
+    The Clebsch-Gordan coefficient will be evaluated via its relation
+    to Wigner 3j symbols:
+
+    .. math::
+
+        \left\langle j_1 m_1 \; j_2 m_2 | j_3 m_3 \right\rangle
+        =(-1)^{j_1-j_2+m_3} \sqrt{2j_3+1}
+        \operatorname{Wigner3j}(j_1,j_2,j_3,m_1,m_2,-m_3)
+
+    See also the documentation on Wigner 3j symbols which exhibit much
+    higher symmetry relations than the Clebsch-Gordan coefficient.
+
+    Authors
+    =======
+
+    - Jens Rasch (2009-03-24): initial version
+    """
+    j_1 = sympify(j_1)
+    j_2 = sympify(j_2)
+    j_3 = sympify(j_3)
+    m_1 = sympify(m_1)
+    m_2 = sympify(m_2)
+    m_3 = sympify(m_3)
+
+    w = wigner_3j(j_1, j_2, j_3, m_1, m_2, -m_3)
+
+    return (-1) ** (j_1 - j_2 + m_3) * sqrt(2 * j_3 + 1) * w
+
+
+def _big_delta_coeff(aa, bb, cc, prec=None):
+    r"""
+    Calculates the Delta coefficient of the 3 angular momenta for
+    Racah symbols. Also checks that the differences are of integer
+    value.
+
+    Parameters
+    ==========
+
+    aa :
+        First angular momentum, integer or half integer.
+    bb :
+        Second angular momentum, integer or half integer.
+    cc :
+        Third angular momentum, integer or half integer.
+    prec :
+        Precision of the ``sqrt()`` calculation.
+
+    Returns
+    =======
+
+    double : Value of the Delta coefficient.
+
+    Examples
+    ========
+
+        sage: from sage.functions.wigner import _big_delta_coeff
+        sage: _big_delta_coeff(1,1,1)
+        1/2*sqrt(1/6)
+    """
+
+    # the triangle test will only pass if a) all 3 values are ints or
+    # b) 1 is an int and the other two are half-ints
+    if not int_valued(aa + bb - cc):
+        raise ValueError("j values must be integer or half integer and fulfill the triangle relation")
+    if not int_valued(aa + cc - bb):
+        raise ValueError("j values must be integer or half integer and fulfill the triangle relation")
+    if not int_valued(bb + cc - aa):
+        raise ValueError("j values must be integer or half integer and fulfill the triangle relation")
+    if (aa + bb - cc) < 0:
+        return S.Zero
+    if (aa + cc - bb) < 0:
+        return S.Zero
+    if (bb + cc - aa) < 0:
+        return S.Zero
+
+    maxfact = max(aa + bb - cc, aa + cc - bb, bb + cc - aa, aa + bb + cc + 1)
+    _calc_factlist(maxfact)
+
+    argsqrt = Integer(_Factlist[int(aa + bb - cc)] *
+                     _Factlist[int(aa + cc - bb)] *
+                     _Factlist[int(bb + cc - aa)]) / \
+        Integer(_Factlist[int(aa + bb + cc + 1)])
+
+    ressqrt = sqrt(argsqrt)
+    if prec:
+        ressqrt = ressqrt.evalf(prec).as_real_imag()[0]
+    return ressqrt
+
+
+def racah(aa, bb, cc, dd, ee, ff, prec=None):
+    r"""
+    Calculate the Racah symbol `W(a,b,c,d;e,f)`.
+
+    Parameters
+    ==========
+
+    a, ..., f :
+        Integer or half integer.
+    prec :
+        Precision, default: ``None``. Providing a precision can
+        drastically speed up the calculation.
+
+    Returns
+    =======
+
+    Rational number times the square root of a rational number
+    (if ``prec=None``), or real number if a precision is given.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.wigner import racah
+    >>> racah(3,3,3,3,3,3)
+    -1/14
+
+    Notes
+    =====
+
+    The Racah symbol is related to the Wigner 6j symbol:
+
+    .. math::
+
+       \operatorname{Wigner6j}(j_1,j_2,j_3,j_4,j_5,j_6)
+       =(-1)^{j_1+j_2+j_4+j_5} W(j_1,j_2,j_5,j_4,j_3,j_6)
+
+    Please see the 6j symbol for its much richer symmetries and for
+    additional properties.
+
+    Algorithm
+    =========
+
+    This function uses the algorithm of [Edmonds74]_ to calculate the
+    value of the 6j symbol exactly. Note that the formula contains
+    alternating sums over large factorials and is therefore unsuitable
+    for finite precision arithmetic and only useful for a computer
+    algebra system [Rasch03]_.
+
+    Authors
+    =======
+
+    - Jens Rasch (2009-03-24): initial version
+    """
+    prefac = _big_delta_coeff(aa, bb, ee, prec) * \
+        _big_delta_coeff(cc, dd, ee, prec) * \
+        _big_delta_coeff(aa, cc, ff, prec) * \
+        _big_delta_coeff(bb, dd, ff, prec)
+    if prefac == 0:
+        return S.Zero
+    imin = max(aa + bb + ee, cc + dd + ee, aa + cc + ff, bb + dd + ff)
+    imax = min(aa + bb + cc + dd, aa + dd + ee + ff, bb + cc + ee + ff)
+
+    maxfact = max(imax + 1, aa + bb + cc + dd, aa + dd + ee + ff,
+                 bb + cc + ee + ff)
+    _calc_factlist(maxfact)
+
+    sumres = 0
+    for kk in range(int(imin), int(imax) + 1):
+        den = _Factlist[int(kk - aa - bb - ee)] * \
+            _Factlist[int(kk - cc - dd - ee)] * \
+            _Factlist[int(kk - aa - cc - ff)] * \
+            _Factlist[int(kk - bb - dd - ff)] * \
+            _Factlist[int(aa + bb + cc + dd - kk)] * \
+            _Factlist[int(aa + dd + ee + ff - kk)] * \
+            _Factlist[int(bb + cc + ee + ff - kk)]
+        sumres = sumres + Integer((-1) ** kk * _Factlist[kk + 1]) / den
+
+    res = prefac * sumres * (-1) ** int(aa + bb + cc + dd)
+    return res
+
+
+def wigner_6j(j_1, j_2, j_3, j_4, j_5, j_6, prec=None):
+    r"""
+    Calculate the Wigner 6j symbol `\operatorname{Wigner6j}(j_1,j_2,j_3,j_4,j_5,j_6)`.
+
+    Parameters
+    ==========
+
+    j_1, ..., j_6 :
+        Integer or half integer.
+    prec :
+        Precision, default: ``None``. Providing a precision can
+        drastically speed up the calculation.
+
+    Returns
+    =======
+
+    Rational number times the square root of a rational number
+    (if ``prec=None``), or real number if a precision is given.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.wigner import wigner_6j
+    >>> wigner_6j(3,3,3,3,3,3)
+    -1/14
+    >>> wigner_6j(5,5,5,5,5,5)
+    1/52
+
+    It is an error to have arguments that are not integer or half
+    integer values or do not fulfill the triangle relation::
+
+        sage: wigner_6j(2.5,2.5,2.5,2.5,2.5,2.5)
+        Traceback (most recent call last):
+        ...
+        ValueError: j values must be integer or half integer and fulfill the triangle relation
+        sage: wigner_6j(0.5,0.5,1.1,0.5,0.5,1.1)
+        Traceback (most recent call last):
+        ...
+        ValueError: j values must be integer or half integer and fulfill the triangle relation
+
+    Notes
+    =====
+
+    The Wigner 6j symbol is related to the Racah symbol but exhibits
+    more symmetries as detailed below.
+
+    .. math::
+
+       \operatorname{Wigner6j}(j_1,j_2,j_3,j_4,j_5,j_6)
+        =(-1)^{j_1+j_2+j_4+j_5} W(j_1,j_2,j_5,j_4,j_3,j_6)
+
+    The Wigner 6j symbol obeys the following symmetry rules:
+
+    - Wigner 6j symbols are left invariant under any permutation of
+      the columns:
+
+      .. math::
+
+         \begin{aligned}
+         \operatorname{Wigner6j}(j_1,j_2,j_3,j_4,j_5,j_6)
+          &=\operatorname{Wigner6j}(j_3,j_1,j_2,j_6,j_4,j_5) \\
+          &=\operatorname{Wigner6j}(j_2,j_3,j_1,j_5,j_6,j_4) \\
+          &=\operatorname{Wigner6j}(j_3,j_2,j_1,j_6,j_5,j_4) \\
+          &=\operatorname{Wigner6j}(j_1,j_3,j_2,j_4,j_6,j_5) \\
+          &=\operatorname{Wigner6j}(j_2,j_1,j_3,j_5,j_4,j_6)
+         \end{aligned}
+
+    - They are invariant under the exchange of the upper and lower
+      arguments in each of any two columns, i.e.
+
+      .. math::
+
+         \begin{aligned}
+         \operatorname{Wigner6j}(j_1,j_2,j_3,j_4,j_5,j_6)
+          &=\operatorname{Wigner6j}(j_1,j_5,j_6,j_4,j_2,j_3)\\
+          &=\operatorname{Wigner6j}(j_4,j_2,j_6,j_1,j_5,j_3)\\
+          &=\operatorname{Wigner6j}(j_4,j_5,j_3,j_1,j_2,j_6)
+         \end{aligned}
+
+    - additional 6 symmetries [Regge59]_ giving rise to 144 symmetries
+      in total
+
+    - only non-zero if any triple of `j`'s fulfill a triangle relation
+
+    Algorithm
+    =========
+
+    This function uses the algorithm of [Edmonds74]_ to calculate the
+    value of the 6j symbol exactly. Note that the formula contains
+    alternating sums over large factorials and is therefore unsuitable
+    for finite precision arithmetic and only useful for a computer
+    algebra system [Rasch03]_.
+
+    """
+    j_1, j_2, j_3, j_4, j_5, j_6 = map(sympify, \
+                [j_1, j_2, j_3, j_4, j_5, j_6])
+    res = (-1) ** int(j_1 + j_2 + j_4 + j_5) * \
+        racah(j_1, j_2, j_5, j_4, j_3, j_6, prec)
+    return res
+
+
+def wigner_9j(j_1, j_2, j_3, j_4, j_5, j_6, j_7, j_8, j_9, prec=None):
+    r"""
+    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)`.
+
+    Parameters
+    ==========
+
+    j_1, ..., j_9 :
+        Integer or half integer.
+    prec : precision, default
+        ``None``. Providing a precision can
+        drastically speed up the calculation.
+
+    Returns
+    =======
+
+    Rational number times the square root of a rational number
+    (if ``prec=None``), or real number if a precision is given.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.wigner import wigner_9j
+    >>> wigner_9j(1,1,1, 1,1,1, 1,1,0, prec=64)
+    0.05555555555555555555555555555555555555555555555555555555555555555
+
+    >>> wigner_9j(1/2,1/2,0, 1/2,3/2,1, 0,1,1, prec=64)
+    0.1666666666666666666666666666666666666666666666666666666666666667
+
+    It is an error to have arguments that are not integer or half
+    integer values or do not fulfill the triangle relation::
+
+        sage: wigner_9j(0.5,0.5,0.5, 0.5,0.5,0.5, 0.5,0.5,0.5,prec=64)
+        Traceback (most recent call last):
+        ...
+        ValueError: j values must be integer or half integer and fulfill the triangle relation
+        sage: wigner_9j(1,1,1, 0.5,1,1.5, 0.5,1,2.5,prec=64)
+        Traceback (most recent call last):
+        ...
+        ValueError: j values must be integer or half integer and fulfill the triangle relation
+
+    Algorithm
+    =========
+
+    This function uses the algorithm of [Edmonds74]_ to calculate the
+    value of the 3j symbol exactly. Note that the formula contains
+    alternating sums over large factorials and is therefore unsuitable
+    for finite precision arithmetic and only useful for a computer
+    algebra system [Rasch03]_.
+    """
+    j_1, j_2, j_3, j_4, j_5, j_6, j_7, j_8, j_9 = map(sympify, \
+                [j_1, j_2, j_3, j_4, j_5, j_6, j_7, j_8, j_9])
+    imax = int(min(j_1 + j_9, j_2 + j_6, j_4 + j_8) * 2)
+    imin = imax % 2
+    sumres = 0
+    for kk in range(imin, int(imax) + 1, 2):
+        sumres = sumres + (kk + 1) * \
+            racah(j_1, j_2, j_9, j_6, j_3, kk / 2, prec) * \
+            racah(j_4, j_6, j_8, j_2, j_5, kk / 2, prec) * \
+            racah(j_1, j_4, j_9, j_8, j_7, kk / 2, prec)
+    return sumres
+
+
+def gaunt(l_1, l_2, l_3, m_1, m_2, m_3, prec=None):
+    r"""
+    Calculate the Gaunt coefficient.
+
+    Explanation
+    ===========
+
+    The Gaunt coefficient is defined as the integral over three
+    spherical harmonics:
+
+    .. math::
+
+        \begin{aligned}
+        \operatorname{Gaunt}(l_1,l_2,l_3,m_1,m_2,m_3)
+        &=\int Y_{l_1,m_1}(\Omega)
+         Y_{l_2,m_2}(\Omega) Y_{l_3,m_3}(\Omega) \,d\Omega \\
+        &=\sqrt{\frac{(2l_1+1)(2l_2+1)(2l_3+1)}{4\pi}}
+         \operatorname{Wigner3j}(l_1,l_2,l_3,0,0,0)
+         \operatorname{Wigner3j}(l_1,l_2,l_3,m_1,m_2,m_3)
+        \end{aligned}
+
+    Parameters
+    ==========
+
+    l_1, l_2, l_3, m_1, m_2, m_3 :
+        Integer.
+    prec - precision, default: ``None``.
+        Providing a precision can
+        drastically speed up the calculation.
+
+    Returns
+    =======
+
+    Rational number times the square root of a rational number
+    (if ``prec=None``), or real number if a precision is given.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.wigner import gaunt
+    >>> gaunt(1,0,1,1,0,-1)
+    -1/(2*sqrt(pi))
+    >>> gaunt(1000,1000,1200,9,3,-12).n(64)
+    0.006895004219221134484332976156744208248842039317638217822322799675
+
+    It is an error to use non-integer values for `l` and `m`::
+
+        sage: gaunt(1.2,0,1.2,0,0,0)
+        Traceback (most recent call last):
+        ...
+        ValueError: l values must be integer
+        sage: gaunt(1,0,1,1.1,0,-1.1)
+        Traceback (most recent call last):
+        ...
+        ValueError: m values must be integer
+
+    Notes
+    =====
+
+    The Gaunt coefficient obeys the following symmetry rules:
+
+    - invariant under any permutation of the columns
+
+      .. math::
+        \begin{aligned}
+          Y(l_1,l_2,l_3,m_1,m_2,m_3)
+          &=Y(l_3,l_1,l_2,m_3,m_1,m_2) \\
+          &=Y(l_2,l_3,l_1,m_2,m_3,m_1) \\
+          &=Y(l_3,l_2,l_1,m_3,m_2,m_1) \\
+          &=Y(l_1,l_3,l_2,m_1,m_3,m_2) \\
+          &=Y(l_2,l_1,l_3,m_2,m_1,m_3)
+        \end{aligned}
+
+    - invariant under space inflection, i.e.
+
+      .. math::
+          Y(l_1,l_2,l_3,m_1,m_2,m_3)
+          =Y(l_1,l_2,l_3,-m_1,-m_2,-m_3)
+
+    - symmetric with respect to the 72 Regge symmetries as inherited
+      for the `3j` symbols [Regge58]_
+
+    - zero for `l_1`, `l_2`, `l_3` not fulfilling triangle relation
+
+    - zero for violating any one of the conditions: `l_1 \ge |m_1|`,
+      `l_2 \ge |m_2|`, `l_3 \ge |m_3|`
+
+    - non-zero only for an even sum of the `l_i`, i.e.
+      `L = l_1 + l_2 + l_3 = 2n` for `n` in `\mathbb{N}`
+
+    Algorithms
+    ==========
+
+    This function uses the algorithm of [Liberatodebrito82]_ to
+    calculate the value of the Gaunt coefficient exactly. Note that
+    the formula contains alternating sums over large factorials and is
+    therefore unsuitable for finite precision arithmetic and only
+    useful for a computer algebra system [Rasch03]_.
+
+    Authors
+    =======
+
+    Jens Rasch (2009-03-24): initial version for Sage.
+    """
+    l_1, l_2, l_3, m_1, m_2, m_3 = [
+        as_int(i) for i in (l_1, l_2, l_3, m_1, m_2, m_3)]
+
+    if l_1 + l_2 - l_3 < 0:
+        return S.Zero
+    if l_1 - l_2 + l_3 < 0:
+        return S.Zero
+    if -l_1 + l_2 + l_3 < 0:
+        return S.Zero
+    if (m_1 + m_2 + m_3) != 0:
+        return S.Zero
+    if (abs(m_1) > l_1) or (abs(m_2) > l_2) or (abs(m_3) > l_3):
+        return S.Zero
+    bigL, remL = divmod(l_1 + l_2 + l_3, 2)
+    if remL % 2:
+        return S.Zero
+
+    imin = max(-l_3 + l_1 + m_2, -l_3 + l_2 - m_1, 0)
+    imax = min(l_2 + m_2, l_1 - m_1, l_1 + l_2 - l_3)
+
+    _calc_factlist(max(l_1 + l_2 + l_3 + 1, imax + 1))
+
+    ressqrt = sqrt((2 * l_1 + 1) * (2 * l_2 + 1) * (2 * l_3 + 1) * \
+        _Factlist[l_1 - m_1] * _Factlist[l_1 + m_1] * _Factlist[l_2 - m_2] * \
+        _Factlist[l_2 + m_2] * _Factlist[l_3 - m_3] * _Factlist[l_3 + m_3] / \
+        (4*pi))
+
+    prefac = Integer(_Factlist[bigL] * _Factlist[l_2 - l_1 + l_3] *
+                     _Factlist[l_1 - l_2 + l_3] * _Factlist[l_1 + l_2 - l_3])/ \
+        _Factlist[2 * bigL + 1]/ \
+        (_Factlist[bigL - l_1] *
+         _Factlist[bigL - l_2] * _Factlist[bigL - l_3])
+
+    sumres = 0
+    for ii in range(int(imin), int(imax) + 1):
+        den = _Factlist[ii] * _Factlist[ii + l_3 - l_1 - m_2] * \
+            _Factlist[l_2 + m_2 - ii] * _Factlist[l_1 - ii - m_1] * \
+            _Factlist[ii + l_3 - l_2 + m_1] * _Factlist[l_1 + l_2 - l_3 - ii]
+        sumres = sumres + Integer((-1) ** ii) / den
+
+    res = ressqrt * prefac * sumres * Integer((-1) ** (bigL + l_3 + m_1 - m_2))
+    if prec is not None:
+        res = res.n(prec)
+    return res
+
+
+def real_gaunt(l_1, l_2, l_3, mu_1, mu_2, mu_3, prec=None):
+    r"""
+    Calculate the real Gaunt coefficient.
+
+    Explanation
+    ===========
+
+    The real Gaunt coefficient is defined as the integral over three
+    real spherical harmonics:
+
+    .. math::
+        \begin{aligned}
+        \operatorname{RealGaunt}(l_1,l_2,l_3,\mu_1,\mu_2,\mu_3)
+        &=\int Z^{\mu_1}_{l_1}(\Omega)
+         Z^{\mu_2}_{l_2}(\Omega) Z^{\mu_3}_{l_3}(\Omega) \,d\Omega \\
+        \end{aligned}
+
+    Alternatively, it can be defined in terms of the standard Gaunt
+    coefficient by relating the real spherical harmonics to the standard
+    spherical harmonics via a unitary transformation `U`, i.e.
+    `Z^{\mu}_{l}(\Omega)=\sum_{m'}U^{\mu}_{m'}Y^{m'}_{l}(\Omega)` [Homeier96]_.
+    The real Gaunt coefficient is then defined as
+
+    .. math::
+        \begin{aligned}
+        \operatorname{RealGaunt}(l_1,l_2,l_3,\mu_1,\mu_2,\mu_3)
+        &=\int Z^{\mu_1}_{l_1}(\Omega)
+         Z^{\mu_2}_{l_2}(\Omega) Z^{\mu_3}_{l_3}(\Omega) \,d\Omega \\
+        &=\sum_{m'_1 m'_2 m'_3} U^{\mu_1}_{m'_1}U^{\mu_2}_{m'_2}U^{\mu_3}_{m'_3}
+         \operatorname{Gaunt}(l_1,l_2,l_3,m'_1,m'_2,m'_3)
+        \end{aligned}
+
+    The unitary matrix `U` has components
+
+    .. math::
+        \begin{aligned}
+        U^\mu_{m} = \delta_{|\mu||m|}*(\delta_{m0}\delta_{\mu 0} + \frac{1}{\sqrt{2}}\big[\Theta(\mu)\big(\delta_{m\mu}+(-1)^{m}\delta_{m-\mu}\big)
+        +i \Theta(-\mu)\big((-1)^{m}\delta_{m\mu}-\delta_{m-\mu}\big)\big])
+        \end{aligned}
+
+
+    where `\delta_{ij}` is the Kronecker delta symbol and `\Theta` is a step
+    function defined as
+
+    .. math::
+        \begin{aligned}
+        \Theta(x) = \begin{cases} 1 \,\text{for}\, x > 0 \\ 0 \,\text{for}\, x \leq 0 \end{cases}
+        \end{aligned}
+
+    Parameters
+    ==========
+
+    l_1, l_2, l_3, mu_1, mu_2, mu_3 :
+        Integer degree and order
+
+    prec - precision, default: ``None``.
+        Providing a precision can
+        drastically speed up the calculation.
+
+    Returns
+    =======
+
+    Rational number times the square root of a rational number.
+
+    Examples
+    ========
+    >>> from sympy.physics.wigner import real_gaunt
+    >>> real_gaunt(1,1,2,-1,1,-2)
+    sqrt(15)/(10*sqrt(pi))
+    >>> real_gaunt(10,10,20,-9,-9,0,prec=64)
+    -0.00002480019791932209313156167176797577821140084216297395518482071448
+
+    It is an error to use non-integer values for `l` and `\mu`::
+        real_gaunt(2.8,0.5,1.3,0,0,0)
+        Traceback (most recent call last):
+        ...
+        ValueError: l values must be integer
+
+        real_gaunt(2,2,4,0.7,1,-3.4)
+        Traceback (most recent call last):
+        ...
+        ValueError: mu values must be integer
+
+    Notes
+    =====
+
+    The real Gaunt coefficient inherits from the standard Gaunt coefficient,
+    the invariance under any permutation of the pairs `(l_i, \mu_i)` and the
+    requirement that the sum of the `l_i` be even to yield a non-zero value.
+    It also obeys the following symmetry rules:
+
+    - zero for `l_1`, `l_2`, `l_3` not fulfilling the condition
+      `l_1 \in \{l_{\text{max}}, l_{\text{max}}-2, \ldots, l_{\text{min}}\}`,
+      where `l_{\text{max}} = l_2+l_3`,
+
+      .. math::
+          \begin{aligned}
+          l_{\text{min}} = \begin{cases} \kappa(l_2, l_3, \mu_2, \mu_3) & \text{if}\,
+          \kappa(l_2, l_3, \mu_2, \mu_3) + l_{\text{max}}\, \text{is even} \\
+          \kappa(l_2, l_3, \mu_2, \mu_3)+1 & \text{if}\, \kappa(l_2, l_3, \mu_2, \mu_3) +
+          l_{\text{max}}\, \text{is odd}\end{cases}
+          \end{aligned}
+
+      and `\kappa(l_2, l_3, \mu_2, \mu_3) = \max{\big(|l_2-l_3|, \min{\big(|\mu_2+\mu_3|,
+      |\mu_2-\mu_3|\big)}\big)}`
+
+    - zero for an odd number of negative `\mu_i`
+
+    Algorithms
+    ==========
+
+    This function uses the algorithms of [Homeier96]_ and [Rasch03]_ to
+    calculate the value of the real Gaunt coefficient exactly. Note that
+    the formula used in [Rasch03]_ contains alternating sums over large
+    factorials and is therefore unsuitable for finite precision arithmetic
+    and only useful for a computer algebra system [Rasch03]_. However, this
+    function can in principle use any algorithm that computes the Gaunt
+    coefficient, so it is suitable for finite precision arithmetic in so far
+    as the algorithm which computes the Gaunt coefficient is.
+    """
+    l_1, l_2, l_3, mu_1, mu_2, mu_3 = [
+        as_int(i) for i in (l_1, l_2, l_3, mu_1, mu_2, mu_3)]
+
+    # check for quick exits
+    if sum(1 for i in (mu_1, mu_2, mu_3) if i < 0) % 2:
+        return S.Zero  # odd number of negative m
+    if (l_1 + l_2 + l_3) % 2:
+        return S.Zero  # sum of l is odd
+    lmax = l_2 + l_3
+    lmin = max(abs(l_2 - l_3), min(abs(mu_2 + mu_3), abs(mu_2 - mu_3)))
+    if (lmin + lmax) % 2:
+        lmin += 1
+    if lmin not in range(lmax, lmin - 2, -2):
+        return S.Zero
+
+    kron_del = lambda i, j: 1 if i == j else 0
+    s = lambda e: -1 if e % 2 else 1  #  (-1)**e to give +/-1, avoiding float when e<0
+
+    t = lambda x: 1 if x > 0 else 0
+    A = lambda mu, m: t(-mu) * (s(m) * kron_del(m, mu) - kron_del(m, -mu))
+    B = lambda mu, m: t(mu) * (kron_del(m, mu) + s(m) * kron_del(m, -mu))
+    U = lambda mu, m: kron_del(abs(mu), abs(m)) * (kron_del(mu, 0) * kron_del(m, 0) + (B(mu, m) + I * A(mu, m))/sqrt(2))
+
+    ugnt = 0
+    for m1 in range(-l_1, l_1+1):
+        U1 = U(mu_1, m1)
+        for m2 in range(-l_2, l_2+1):
+            U2 = U(mu_2, m2)
+            U3 = U(mu_3,-m1-m2)
+            ugnt = ugnt + re(U1*U2*U3)*gaunt(l_1, l_2, l_3, m1, m2, -m1 - m2, prec=prec)
+
+    return ugnt
+
+
+class Wigner3j(Function):
+
+    def doit(self, **hints):
+        if all(obj.is_number for obj in self.args):
+            return wigner_3j(*self.args)
+        else:
+            return self
+
+def dot_rot_grad_Ynm(j, p, l, m, theta, phi):
+    r"""
+    Returns dot product of rotational gradients of spherical harmonics.
+
+    Explanation
+    ===========
+
+    This function returns the right hand side of the following expression:
+
+    .. math ::
+        \vec{R}Y{_j^{p}} \cdot \vec{R}Y{_l^{m}} = (-1)^{m+p}
+        \sum\limits_{k=|l-j|}^{l+j}Y{_k^{m+p}}  * \alpha_{l,m,j,p,k} *
+        \frac{1}{2} (k^2-j^2-l^2+k-j-l)
+
+
+    Arguments
+    =========
+
+    j, p, l, m .... indices in spherical harmonics (expressions or integers)
+    theta, phi .... angle arguments in spherical harmonics
+
+    Example
+    =======
+
+    >>> from sympy import symbols
+    >>> from sympy.physics.wigner import dot_rot_grad_Ynm
+    >>> theta, phi = symbols("theta phi")
+    >>> dot_rot_grad_Ynm(3, 2, 2, 0, theta, phi).doit()
+    3*sqrt(55)*Ynm(5, 2, theta, phi)/(11*sqrt(pi))
+
+    """
+    j = sympify(j)
+    p = sympify(p)
+    l = sympify(l)
+    m = sympify(m)
+    theta = sympify(theta)
+    phi = sympify(phi)
+    k = Dummy("k")
+
+    def alpha(l,m,j,p,k):
+        return sqrt((2*l+1)*(2*j+1)*(2*k+1)/(4*pi)) * \
+                Wigner3j(j, l, k, S.Zero, S.Zero, S.Zero) * \
+                Wigner3j(j, l, k, p, m, -m-p)
+
+    return (S.NegativeOne)**(m+p) * Sum(Ynm(k, m+p, theta, phi) * alpha(l,m,j,p,k) / 2 \
+        *(k**2-j**2-l**2+k-j-l), (k, abs(l-j), l+j))
+
+
+def wigner_d_small(J, beta):
+    """Return the small Wigner d matrix for angular momentum J.
+
+    Explanation
+    ===========
+
+    J : An integer, half-integer, or SymPy symbol for the total angular
+        momentum of the angular momentum space being rotated.
+    beta : A real number representing the Euler angle of rotation about
+        the so-called line of nodes. See [Edmonds74]_.
+
+    Returns
+    =======
+
+    A matrix representing the corresponding Euler angle rotation( in the basis
+    of eigenvectors of `J_z`).
+
+    .. math ::
+        \\mathcal{d}_{\\beta} = \\exp\\big( \\frac{i\\beta}{\\hbar} J_y\\big)
+
+    such that
+
+    .. math ::
+        d^{(J)}_{m',m}(\\beta) = \\mathtt{wigner\\_d\\_small(J,beta)[J-mprime,J-m]}
+
+    The components are calculated using the general form [Edmonds74]_,
+    equation 4.1.15.
+
+    Examples
+    ========
+
+    >>> from sympy import Integer, symbols, pi, pprint
+    >>> from sympy.physics.wigner import wigner_d_small
+    >>> half = 1/Integer(2)
+    >>> beta = symbols("beta", real=True)
+    >>> pprint(wigner_d_small(half, beta), use_unicode=True)
+    ⎡   ⎛β⎞      ⎛β⎞⎤
+    ⎢cos⎜─⎟   sin⎜─⎟⎥
+    ⎢   ⎝2⎠      ⎝2⎠⎥
+    ⎢               ⎥
+    ⎢    ⎛β⎞     ⎛β⎞⎥
+    ⎢-sin⎜─⎟  cos⎜─⎟⎥
+    ⎣    ⎝2⎠     ⎝2⎠⎦
+
+    >>> pprint(wigner_d_small(2*half, beta), use_unicode=True)
+    ⎡        2⎛β⎞              ⎛β⎞    ⎛β⎞           2⎛β⎞     ⎤
+    ⎢     cos ⎜─⎟        √2⋅sin⎜─⎟⋅cos⎜─⎟        sin ⎜─⎟     ⎥
+    ⎢         ⎝2⎠              ⎝2⎠    ⎝2⎠            ⎝2⎠     ⎥
+    ⎢                                                        ⎥
+    ⎢       ⎛β⎞    ⎛β⎞       2⎛β⎞      2⎛β⎞        ⎛β⎞    ⎛β⎞⎥
+    ⎢-√2⋅sin⎜─⎟⋅cos⎜─⎟  - sin ⎜─⎟ + cos ⎜─⎟  √2⋅sin⎜─⎟⋅cos⎜─⎟⎥
+    ⎢       ⎝2⎠    ⎝2⎠        ⎝2⎠       ⎝2⎠        ⎝2⎠    ⎝2⎠⎥
+    ⎢                                                        ⎥
+    ⎢        2⎛β⎞               ⎛β⎞    ⎛β⎞          2⎛β⎞     ⎥
+    ⎢     sin ⎜─⎟        -√2⋅sin⎜─⎟⋅cos⎜─⎟       cos ⎜─⎟     ⎥
+    ⎣         ⎝2⎠               ⎝2⎠    ⎝2⎠           ⎝2⎠     ⎦
+
+    From table 4 in [Edmonds74]_
+
+    >>> pprint(wigner_d_small(half, beta).subs({beta:pi/2}), use_unicode=True)
+    ⎡ √2   √2⎤
+    ⎢ ──   ──⎥
+    ⎢ 2    2 ⎥
+    ⎢        ⎥
+    ⎢-√2   √2⎥
+    ⎢────  ──⎥
+    ⎣ 2    2 ⎦
+
+    >>> pprint(wigner_d_small(2*half, beta).subs({beta:pi/2}),
+    ... use_unicode=True)
+    ⎡       √2      ⎤
+    ⎢1/2    ──   1/2⎥
+    ⎢       2       ⎥
+    ⎢               ⎥
+    ⎢-√2         √2 ⎥
+    ⎢────   0    ── ⎥
+    ⎢ 2          2  ⎥
+    ⎢               ⎥
+    ⎢      -√2      ⎥
+    ⎢1/2   ────  1/2⎥
+    ⎣       2       ⎦
+
+    >>> pprint(wigner_d_small(3*half, beta).subs({beta:pi/2}),
+    ... use_unicode=True)
+    ⎡ √2    √6    √6   √2⎤
+    ⎢ ──    ──    ──   ──⎥
+    ⎢ 4     4     4    4 ⎥
+    ⎢                    ⎥
+    ⎢-√6   -√2    √2   √6⎥
+    ⎢────  ────   ──   ──⎥
+    ⎢ 4     4     4    4 ⎥
+    ⎢                    ⎥
+    ⎢ √6   -√2   -√2   √6⎥
+    ⎢ ──   ────  ────  ──⎥
+    ⎢ 4     4     4    4 ⎥
+    ⎢                    ⎥
+    ⎢-√2    √6   -√6   √2⎥
+    ⎢────   ──   ────  ──⎥
+    ⎣ 4     4     4    4 ⎦
+
+    >>> pprint(wigner_d_small(4*half, beta).subs({beta:pi/2}),
+    ... use_unicode=True)
+    ⎡             √6            ⎤
+    ⎢1/4   1/2    ──   1/2   1/4⎥
+    ⎢             4             ⎥
+    ⎢                           ⎥
+    ⎢-1/2  -1/2   0    1/2   1/2⎥
+    ⎢                           ⎥
+    ⎢ √6                     √6 ⎥
+    ⎢ ──    0    -1/2   0    ── ⎥
+    ⎢ 4                      4  ⎥
+    ⎢                           ⎥
+    ⎢-1/2  1/2    0    -1/2  1/2⎥
+    ⎢                           ⎥
+    ⎢             √6            ⎥
+    ⎢1/4   -1/2   ──   -1/2  1/4⎥
+    ⎣             4             ⎦
+
+    """
+    M = [J-i for i in range(2*J+1)]
+    d = zeros(2*J+1)
+
+    # Mi corresponds to Edmonds' $m'$, and Mj to $m$.
+    for i, Mi in enumerate(M):
+        for j, Mj in enumerate(M):
+
+            # We get the maximum and minimum value of sigma.
+            sigmamax = min([J-Mi, J-Mj])
+            sigmamin = max([0, -Mi-Mj])
+
+            dij = sqrt(factorial(J+Mi)*factorial(J-Mi) /
+                       factorial(J+Mj)/factorial(J-Mj))
+            terms = [(-1)**(J-Mi-s) *
+                     binomial(J+Mj, J-Mi-s) *
+                     binomial(J-Mj, s) *
+                     cos(beta/2)**(2*s+Mi+Mj) *
+                     sin(beta/2)**(2*J-2*s-Mj-Mi)
+                     for s in range(sigmamin, sigmamax+1)]
+
+            d[i, j] = dij*Add(*terms)
+
+    return ImmutableMatrix(d)
+
+
+def wigner_d(J, alpha, beta, gamma):
+    """Return the Wigner D matrix for angular momentum J.
+
+    Explanation
+    ===========
+
+    J :
+        An integer, half-integer, or SymPy symbol for the total angular
+        momentum of the angular momentum space being rotated.
+    alpha, beta, gamma - Real numbers representing the Euler.
+        Angles of rotation about the so-called figure axis, line of nodes,
+        and vertical. See [Edmonds74]_, however note that the symbols alpha
+        and gamma are swapped in this implementation.
+
+    Returns
+    =======
+
+    A matrix representing the corresponding Euler angle rotation (in the basis
+    of eigenvectors of `J_z`).
+
+    .. math ::
+        \\mathcal{D}_{\\alpha \\beta \\gamma} =
+        \\exp\\big( \\frac{i\\alpha}{\\hbar} J_z\\big)
+        \\exp\\big( \\frac{i\\beta}{\\hbar} J_y\\big)
+        \\exp\\big( \\frac{i\\gamma}{\\hbar} J_z\\big)
+
+    such that
+
+    .. math ::
+        \\mathcal{D}^{(J)}_{m',m}(\\alpha, \\beta, \\gamma) =
+        \\mathtt{wigner_d(J, alpha, beta, gamma)[J-mprime,J-m]}
+
+    The components are calculated using the general form [Edmonds74]_,
+    equation 4.1.12, however note that the angles alpha and gamma are swapped
+    in this implementation.
+
+    Examples
+    ========
+
+    The simplest possible example:
+
+    >>> from sympy.physics.wigner import wigner_d
+    >>> from sympy import Integer, symbols, pprint
+    >>> half = 1/Integer(2)
+    >>> alpha, beta, gamma = symbols("alpha, beta, gamma", real=True)
+    >>> pprint(wigner_d(half, alpha, beta, gamma), use_unicode=True)
+    ⎡  ⅈ⋅α  ⅈ⋅γ             ⅈ⋅α  -ⅈ⋅γ         ⎤
+    ⎢  ───  ───             ───  ─────        ⎥
+    ⎢   2    2     ⎛β⎞       2     2      ⎛β⎞ ⎥
+    ⎢ ℯ   ⋅ℯ   ⋅cos⎜─⎟     ℯ   ⋅ℯ     ⋅sin⎜─⎟ ⎥
+    ⎢              ⎝2⎠                    ⎝2⎠ ⎥
+    ⎢                                         ⎥
+    ⎢  -ⅈ⋅α   ⅈ⋅γ          -ⅈ⋅α   -ⅈ⋅γ        ⎥
+    ⎢  ─────  ───          ─────  ─────       ⎥
+    ⎢    2     2     ⎛β⎞     2      2      ⎛β⎞⎥
+    ⎢-ℯ     ⋅ℯ   ⋅sin⎜─⎟  ℯ     ⋅ℯ     ⋅cos⎜─⎟⎥
+    ⎣                ⎝2⎠                   ⎝2⎠⎦
+
+    """
+    d = wigner_d_small(J, beta)
+    M = [J-i for i in range(2*J+1)]
+    # Mi corresponds to Edmonds' $m'$, and Mj to $m$.
+    D = [[exp(I*Mi*alpha)*d[i, j]*exp(I*Mj*gamma)
+          for j, Mj in enumerate(M)] for i, Mi in enumerate(M)]
+    return ImmutableMatrix(D)

venv/lib/python3.11/site-packages/sympy/plotting/__init__.py

@@ -0,0 +1,22 @@
+from .plot import plot_backends
+from .plot_implicit import plot_implicit
+from .textplot import textplot
+from .pygletplot import PygletPlot
+from .plot import PlotGrid
+from .plot import (plot, plot_parametric, plot3d, plot3d_parametric_surface,
+                  plot3d_parametric_line, plot_contour)
+
+__all__ = [
+    'plot_backends',
+
+    'plot_implicit',
+
+    'textplot',
+
+    'PygletPlot',
+
+    'PlotGrid',
+
+    'plot', 'plot_parametric', 'plot3d', 'plot3d_parametric_surface',
+    'plot3d_parametric_line', 'plot_contour'
+]

venv/lib/python3.11/site-packages/sympy/plotting/backends/base_backend.py

@@ -0,0 +1,419 @@
+from sympy.plotting.series import BaseSeries, GenericDataSeries
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.iterables import is_sequence
+
+
+__doctest_requires__ = {
+    ('Plot.append', 'Plot.extend'): ['matplotlib'],
+}
+
+
+# Global variable
+# Set to False when running tests / doctests so that the plots don't show.
+_show = True
+
+def unset_show():
+    """
+    Disable show(). For use in the tests.
+    """
+    global _show
+    _show = False
+
+
+def _deprecation_msg_m_a_r_f(attr):
+    sympy_deprecation_warning(
+        f"The `{attr}` property is deprecated. The `{attr}` keyword "
+        "argument should be passed to a plotting function, which generates "
+        "the appropriate data series. If needed, index the plot object to "
+        "retrieve a specific data series.",
+        deprecated_since_version="1.13",
+        active_deprecations_target="deprecated-markers-annotations-fill-rectangles",
+        stacklevel=4)
+
+
+def _create_generic_data_series(**kwargs):
+    keywords = ["annotations", "markers", "fill", "rectangles"]
+    series = []
+    for kw in keywords:
+        dictionaries = kwargs.pop(kw, [])
+        if dictionaries is None:
+            dictionaries = []
+        if isinstance(dictionaries, dict):
+            dictionaries = [dictionaries]
+        for d in dictionaries:
+            args = d.pop("args", [])
+            series.append(GenericDataSeries(kw, *args, **d))
+    return series
+
+
+class Plot:
+    """Base class for all backends. A backend represents the plotting library,
+    which implements the necessary functionalities in order to use SymPy
+    plotting functions.
+
+    For interactive work the function :func:`plot` is better suited.
+
+    This class permits the plotting of SymPy expressions using numerous
+    backends (:external:mod:`matplotlib`, textplot, the old pyglet module for SymPy, Google
+    charts api, etc).
+
+    The figure can contain an arbitrary number of plots of SymPy expressions,
+    lists of coordinates of points, etc. Plot has a private attribute _series that
+    contains all data series to be plotted (expressions for lines or surfaces,
+    lists of points, etc (all subclasses of BaseSeries)). Those data series are
+    instances of classes not imported by ``from sympy import *``.
+
+    The customization of the figure is on two levels. Global options that
+    concern the figure as a whole (e.g. title, xlabel, scale, etc) and
+    per-data series options (e.g. name) and aesthetics (e.g. color, point shape,
+    line type, etc.).
+
+    The difference between options and aesthetics is that an aesthetic can be
+    a function of the coordinates (or parameters in a parametric plot). The
+    supported values for an aesthetic are:
+
+    - None (the backend uses default values)
+    - a constant
+    - a function of one variable (the first coordinate or parameter)
+    - a function of two variables (the first and second coordinate or parameters)
+    - a function of three variables (only in nonparametric 3D plots)
+
+    Their implementation depends on the backend so they may not work in some
+    backends.
+
+    If the plot is parametric and the arity of the aesthetic function permits
+    it the aesthetic is calculated over parameters and not over coordinates.
+    If the arity does not permit calculation over parameters the calculation is
+    done over coordinates.
+
+    Only cartesian coordinates are supported for the moment, but you can use
+    the parametric plots to plot in polar, spherical and cylindrical
+    coordinates.
+
+    The arguments for the constructor Plot must be subclasses of BaseSeries.
+
+    Any global option can be specified as a keyword argument.
+
+    The global options for a figure are:
+
+    - title : str
+    - xlabel : str or Symbol
+    - ylabel : str or Symbol
+    - zlabel : str or Symbol
+    - legend : bool
+    - xscale : {'linear', 'log'}
+    - yscale : {'linear', 'log'}
+    - axis : bool
+    - axis_center : tuple of two floats or {'center', 'auto'}
+    - xlim : tuple of two floats
+    - ylim : tuple of two floats
+    - aspect_ratio : tuple of two floats or {'auto'}
+    - autoscale : bool
+    - margin : float in [0, 1]
+    - backend : {'default', 'matplotlib', 'text'} or a subclass of BaseBackend
+    - size : optional tuple of two floats, (width, height); default: None
+
+    The per data series options and aesthetics are:
+    There are none in the base series. See below for options for subclasses.
+
+    Some data series support additional aesthetics or options:
+
+    :class:`~.LineOver1DRangeSeries`, :class:`~.Parametric2DLineSeries`, and
+    :class:`~.Parametric3DLineSeries` support the following:
+
+    Aesthetics:
+
+    - line_color : string, or float, or function, optional
+        Specifies the color for the plot, which depends on the backend being
+        used.
+
+        For example, if ``MatplotlibBackend`` is being used, then
+        Matplotlib string colors are acceptable (``"red"``, ``"r"``,
+        ``"cyan"``, ``"c"``, ...).
+        Alternatively, we can use a float number, 0 < color < 1, wrapped in a
+        string (for example, ``line_color="0.5"``) to specify grayscale colors.
+        Alternatively, We can specify a function returning a single
+        float value: this will be used to apply a color-loop (for example,
+        ``line_color=lambda x: math.cos(x)``).
+
+        Note that by setting line_color, it would be applied simultaneously
+        to all the series.
+
+    Options:
+
+    - label : str
+    - steps : bool
+    - integers_only : bool
+
+    :class:`~.SurfaceOver2DRangeSeries` and :class:`~.ParametricSurfaceSeries`
+    support the following:
+
+    Aesthetics:
+
+    - surface_color : function which returns a float.
+
+    Notes
+    =====
+
+    How the plotting module works:
+
+    1. Whenever a plotting function is called, the provided expressions are
+       processed and a list of instances of the
+       :class:`~sympy.plotting.series.BaseSeries` class is created, containing
+       the necessary information to plot the expressions
+       (e.g. the expression, ranges, series name, ...). Eventually, these
+       objects will generate the numerical data to be plotted.
+    2. A subclass of :class:`~.Plot` class is instantiaed (referred to as
+       backend, from now on), which stores the list of series and the main
+       attributes of the plot (e.g. axis labels, title, ...).
+       The backend implements the logic to generate the actual figure with
+       some plotting library.
+    3. When the ``show`` command is executed, series are processed one by one
+       to generate numerical data and add it to the figure. The backend is also
+       going to set the axis labels, title, ..., according to the values stored
+       in the Plot instance.
+
+    The backend should check if it supports the data series that it is given
+    (e.g. :class:`TextBackend` supports only
+    :class:`~sympy.plotting.series.LineOver1DRangeSeries`).
+
+    It is the backend responsibility to know how to use the class of data series
+    that it's given. Note that the current implementation of the ``*Series``
+    classes is "matplotlib-centric": the numerical data returned by the
+    ``get_points`` and ``get_meshes`` methods is meant to be used directly by
+    Matplotlib. Therefore, the new backend will have to pre-process the
+    numerical data to make it compatible with the chosen plotting library.
+    Keep in mind that future SymPy versions may improve the ``*Series`` classes
+    in order to return numerical data "non-matplotlib-centric", hence if you code
+    a new backend you have the responsibility to check if its working on each
+    SymPy release.
+
+    Please explore the :class:`MatplotlibBackend` source code to understand
+    how a backend should be coded.
+
+    In order to be used by SymPy plotting functions, a backend must implement
+    the following methods:
+
+    * show(self): used to loop over the data series, generate the numerical
+        data, plot it and set the axis labels, title, ...
+    * save(self, path): used to save the current plot to the specified file
+        path.
+    * close(self): used to close the current plot backend (note: some plotting
+        library does not support this functionality. In that case, just raise a
+        warning).
+    """
+
+    def __init__(self, *args,
+        title=None, xlabel=None, ylabel=None, zlabel=None, aspect_ratio='auto',
+        xlim=None, ylim=None, axis_center='auto', axis=True,
+        xscale='linear', yscale='linear', legend=False, autoscale=True,
+        margin=0, annotations=None, markers=None, rectangles=None,
+        fill=None, backend='default', size=None, **kwargs):
+
+        # Options for the graph as a whole.
+        # The possible values for each option are described in the docstring of
+        # Plot. They are based purely on convention, no checking is done.
+        self.title = title
+        self.xlabel = xlabel
+        self.ylabel = ylabel
+        self.zlabel = zlabel
+        self.aspect_ratio = aspect_ratio
+        self.axis_center = axis_center
+        self.axis = axis
+        self.xscale = xscale
+        self.yscale = yscale
+        self.legend = legend
+        self.autoscale = autoscale
+        self.margin = margin
+        self._annotations = annotations
+        self._markers = markers
+        self._rectangles = rectangles
+        self._fill = fill
+
+        # Contains the data objects to be plotted. The backend should be smart
+        # enough to iterate over this list.
+        self._series = []
+        self._series.extend(args)
+        self._series.extend(_create_generic_data_series(
+            annotations=annotations, markers=markers, rectangles=rectangles,
+            fill=fill))
+
+        is_real = \
+            lambda lim: all(getattr(i, 'is_real', True) for i in lim)
+        is_finite = \
+            lambda lim: all(getattr(i, 'is_finite', True) for i in lim)
+
+        # reduce code repetition
+        def check_and_set(t_name, t):
+            if t:
+                if not is_real(t):
+                    raise ValueError(
+                    "All numbers from {}={} must be real".format(t_name, t))
+                if not is_finite(t):
+                    raise ValueError(
+                    "All numbers from {}={} must be finite".format(t_name, t))
+                setattr(self, t_name, (float(t[0]), float(t[1])))
+
+        self.xlim = None
+        check_and_set("xlim", xlim)
+        self.ylim = None
+        check_and_set("ylim", ylim)
+        self.size = None
+        check_and_set("size", size)
+
+    @property
+    def _backend(self):
+        return self
+
+    @property
+    def backend(self):
+        return type(self)
+
+    def __str__(self):
+        series_strs = [('[%d]: ' % i) + str(s)
+                       for i, s in enumerate(self._series)]
+        return 'Plot object containing:\n' + '\n'.join(series_strs)
+
+    def __getitem__(self, index):
+        return self._series[index]
+
+    def __setitem__(self, index, *args):
+        if len(args) == 1 and isinstance(args[0], BaseSeries):
+            self._series[index] = args
+
+    def __delitem__(self, index):
+        del self._series[index]
+
+    def append(self, arg):
+        """Adds an element from a plot's series to an existing plot.
+
+        Examples
+        ========
+
+        Consider two ``Plot`` objects, ``p1`` and ``p2``. To add the
+        second plot's first series object to the first, use the
+        ``append`` method, like so:
+
+        .. plot::
+           :format: doctest
+           :include-source: True
+
+           >>> from sympy import symbols
+           >>> from sympy.plotting import plot
+           >>> x = symbols('x')
+           >>> p1 = plot(x*x, show=False)
+           >>> p2 = plot(x, show=False)
+           >>> p1.append(p2[0])
+           >>> p1
+           Plot object containing:
+           [0]: cartesian line: x**2 for x over (-10.0, 10.0)
+           [1]: cartesian line: x for x over (-10.0, 10.0)
+           >>> p1.show()
+
+        See Also
+        ========
+
+        extend
+
+        """
+        if isinstance(arg, BaseSeries):
+            self._series.append(arg)
+        else:
+            raise TypeError('Must specify element of plot to append.')
+
+    def extend(self, arg):
+        """Adds all series from another plot.
+
+        Examples
+        ========
+
+        Consider two ``Plot`` objects, ``p1`` and ``p2``. To add the
+        second plot to the first, use the ``extend`` method, like so:
+
+        .. plot::
+           :format: doctest
+           :include-source: True
+
+           >>> from sympy import symbols
+           >>> from sympy.plotting import plot
+           >>> x = symbols('x')
+           >>> p1 = plot(x**2, show=False)
+           >>> p2 = plot(x, -x, show=False)
+           >>> p1.extend(p2)
+           >>> p1
+           Plot object containing:
+           [0]: cartesian line: x**2 for x over (-10.0, 10.0)
+           [1]: cartesian line: x for x over (-10.0, 10.0)
+           [2]: cartesian line: -x for x over (-10.0, 10.0)
+           >>> p1.show()
+
+        """
+        if isinstance(arg, Plot):
+            self._series.extend(arg._series)
+        elif is_sequence(arg):
+            self._series.extend(arg)
+        else:
+            raise TypeError('Expecting Plot or sequence of BaseSeries')
+
+    def show(self):
+        raise NotImplementedError
+
+    def save(self, path):
+        raise NotImplementedError
+
+    def close(self):
+        raise NotImplementedError
+
+    # deprecations
+
+    @property
+    def markers(self):
+        """.. deprecated:: 1.13"""
+        _deprecation_msg_m_a_r_f("markers")
+        return self._markers
+
+    @markers.setter
+    def markers(self, v):
+        """.. deprecated:: 1.13"""
+        _deprecation_msg_m_a_r_f("markers")
+        self._series.extend(_create_generic_data_series(markers=v))
+        self._markers = v
+
+    @property
+    def annotations(self):
+        """.. deprecated:: 1.13"""
+        _deprecation_msg_m_a_r_f("annotations")
+        return self._annotations
+
+    @annotations.setter
+    def annotations(self, v):
+        """.. deprecated:: 1.13"""
+        _deprecation_msg_m_a_r_f("annotations")
+        self._series.extend(_create_generic_data_series(annotations=v))
+        self._annotations = v
+
+    @property
+    def rectangles(self):
+        """.. deprecated:: 1.13"""
+        _deprecation_msg_m_a_r_f("rectangles")
+        return self._rectangles
+
+    @rectangles.setter
+    def rectangles(self, v):
+        """.. deprecated:: 1.13"""
+        _deprecation_msg_m_a_r_f("rectangles")
+        self._series.extend(_create_generic_data_series(rectangles=v))
+        self._rectangles = v
+
+    @property
+    def fill(self):
+        """.. deprecated:: 1.13"""
+        _deprecation_msg_m_a_r_f("fill")
+        return self._fill
+
+    @fill.setter
+    def fill(self, v):
+        """.. deprecated:: 1.13"""
+        _deprecation_msg_m_a_r_f("fill")
+        self._series.extend(_create_generic_data_series(fill=v))
+        self._fill = v

venv/lib/python3.11/site-packages/sympy/plotting/backends/matplotlibbackend/__init__.py

@@ -0,0 +1,5 @@
+from sympy.plotting.backends.matplotlibbackend.matplotlib import (
+    MatplotlibBackend, _matplotlib_list
+)
+
+__all__ = ["MatplotlibBackend", "_matplotlib_list"]

venv/lib/python3.11/site-packages/sympy/plotting/backends/matplotlibbackend/matplotlib.py

@@ -0,0 +1,318 @@
+from collections.abc import Callable
+from sympy.core.basic import Basic
+from sympy.external import import_module
+import sympy.plotting.backends.base_backend as base_backend
+from sympy.printing.latex import latex
+
+
+# N.B.
+# When changing the minimum module version for matplotlib, please change
+# the same in the `SymPyDocTestFinder`` in `sympy/testing/runtests.py`
+
+
+def _str_or_latex(label):
+    if isinstance(label, Basic):
+        return latex(label, mode='inline')
+    return str(label)
+
+
+def _matplotlib_list(interval_list):
+    """
+    Returns lists for matplotlib ``fill`` command from a list of bounding
+    rectangular intervals
+    """
+    xlist = []
+    ylist = []
+    if len(interval_list):
+        for intervals in interval_list:
+            intervalx = intervals[0]
+            intervaly = intervals[1]
+            xlist.extend([intervalx.start, intervalx.start,
+                          intervalx.end, intervalx.end, None])
+            ylist.extend([intervaly.start, intervaly.end,
+                          intervaly.end, intervaly.start, None])
+    else:
+        #XXX Ugly hack. Matplotlib does not accept empty lists for ``fill``
+        xlist.extend((None, None, None, None))
+        ylist.extend((None, None, None, None))
+    return xlist, ylist
+
+
+# Don't have to check for the success of importing matplotlib in each case;
+# we will only be using this backend if we can successfully import matploblib
+class MatplotlibBackend(base_backend.Plot):
+    """ This class implements the functionalities to use Matplotlib with SymPy
+    plotting functions.
+    """
+
+    def __init__(self, *series, **kwargs):
+        super().__init__(*series, **kwargs)
+        self.matplotlib = import_module('matplotlib',
+            import_kwargs={'fromlist': ['pyplot', 'cm', 'collections']},
+            min_module_version='1.1.0', catch=(RuntimeError,))
+        self.plt = self.matplotlib.pyplot
+        self.cm = self.matplotlib.cm
+        self.LineCollection = self.matplotlib.collections.LineCollection
+        self.aspect = kwargs.get('aspect_ratio', 'auto')
+        if self.aspect != 'auto':
+            self.aspect = float(self.aspect[1]) / self.aspect[0]
+        # PlotGrid can provide its figure and axes to be populated with
+        # the data from the series.
+        self._plotgrid_fig = kwargs.pop("fig", None)
+        self._plotgrid_ax = kwargs.pop("ax", None)
+
+    def _create_figure(self):
+        def set_spines(ax):
+            ax.spines['left'].set_position('zero')
+            ax.spines['right'].set_color('none')
+            ax.spines['bottom'].set_position('zero')
+            ax.spines['top'].set_color('none')
+            ax.xaxis.set_ticks_position('bottom')
+            ax.yaxis.set_ticks_position('left')
+
+        if self._plotgrid_fig is not None:
+            self.fig = self._plotgrid_fig
+            self.ax = self._plotgrid_ax
+            if not any(s.is_3D for s in self._series):
+                set_spines(self.ax)
+        else:
+            self.fig = self.plt.figure(figsize=self.size)
+            if any(s.is_3D for s in self._series):
+                self.ax = self.fig.add_subplot(1, 1, 1, projection="3d")
+            else:
+                self.ax = self.fig.add_subplot(1, 1, 1)
+                set_spines(self.ax)
+
+    @staticmethod
+    def get_segments(x, y, z=None):
+        """ Convert two list of coordinates to a list of segments to be used
+        with Matplotlib's :external:class:`~matplotlib.collections.LineCollection`.
+
+        Parameters
+        ==========
+            x : list
+                List of x-coordinates
+
+            y : list
+                List of y-coordinates
+
+            z : list
+                List of z-coordinates for a 3D line.
+        """
+        np = import_module('numpy')
+        if z is not None:
+            dim = 3
+            points = (x, y, z)
+        else:
+            dim = 2
+            points = (x, y)
+        points = np.ma.array(points).T.reshape(-1, 1, dim)
+        return np.ma.concatenate([points[:-1], points[1:]], axis=1)
+
+    def _process_series(self, series, ax):
+        np = import_module('numpy')
+        mpl_toolkits = import_module(
+            'mpl_toolkits', import_kwargs={'fromlist': ['mplot3d']})
+
+        # XXX Workaround for matplotlib issue
+        # https://github.com/matplotlib/matplotlib/issues/17130
+        xlims, ylims, zlims = [], [], []
+
+        for s in series:
+            # Create the collections
+            if s.is_2Dline:
+                if s.is_parametric:
+                    x, y, param = s.get_data()
+                else:
+                    x, y = s.get_data()
+                if (isinstance(s.line_color, (int, float)) or
+                        callable(s.line_color)):
+                    segments = self.get_segments(x, y)
+                    collection = self.LineCollection(segments)
+                    collection.set_array(s.get_color_array())
+                    ax.add_collection(collection)
+                else:
+                    lbl = _str_or_latex(s.label)
+                    line, = ax.plot(x, y, label=lbl, color=s.line_color)
+            elif s.is_contour:
+                ax.contour(*s.get_data())
+            elif s.is_3Dline:
+                x, y, z, param = s.get_data()
+                if (isinstance(s.line_color, (int, float)) or
+                        callable(s.line_color)):
+                    art3d = mpl_toolkits.mplot3d.art3d
+                    segments = self.get_segments(x, y, z)
+                    collection = art3d.Line3DCollection(segments)
+                    collection.set_array(s.get_color_array())
+                    ax.add_collection(collection)
+                else:
+                    lbl = _str_or_latex(s.label)
+                    ax.plot(x, y, z, label=lbl, color=s.line_color)
+
+                xlims.append(s._xlim)
+                ylims.append(s._ylim)
+                zlims.append(s._zlim)
+            elif s.is_3Dsurface:
+                if s.is_parametric:
+                    x, y, z, u, v = s.get_data()
+                else:
+                    x, y, z = s.get_data()
+                collection = ax.plot_surface(x, y, z,
+                    cmap=getattr(self.cm, 'viridis', self.cm.jet),
+                    rstride=1, cstride=1, linewidth=0.1)
+                if isinstance(s.surface_color, (float, int, Callable)):
+                    color_array = s.get_color_array()
+                    color_array = color_array.reshape(color_array.size)
+                    collection.set_array(color_array)
+                else:
+                    collection.set_color(s.surface_color)
+
+                xlims.append(s._xlim)
+                ylims.append(s._ylim)
+                zlims.append(s._zlim)
+            elif s.is_implicit:
+                points = s.get_data()
+                if len(points) == 2:
+                    # interval math plotting
+                    x, y = _matplotlib_list(points[0])
+                    ax.fill(x, y, facecolor=s.line_color, edgecolor='None')
+                else:
+                    # use contourf or contour depending on whether it is
+                    # an inequality or equality.
+                    # XXX: ``contour`` plots multiple lines. Should be fixed.
+                    ListedColormap = self.matplotlib.colors.ListedColormap
+                    colormap = ListedColormap(["white", s.line_color])
+                    xarray, yarray, zarray, plot_type = points
+                    if plot_type == 'contour':
+                        ax.contour(xarray, yarray, zarray, cmap=colormap)
+                    else:
+                        ax.contourf(xarray, yarray, zarray, cmap=colormap)
+            elif s.is_generic:
+                if s.type == "markers":
+                    # s.rendering_kw["color"] = s.line_color
+                    ax.plot(*s.args, **s.rendering_kw)
+                elif s.type == "annotations":
+                    ax.annotate(*s.args, **s.rendering_kw)
+                elif s.type == "fill":
+                    # s.rendering_kw["color"] = s.line_color
+                    ax.fill_between(*s.args, **s.rendering_kw)
+                elif s.type == "rectangles":
+                    # s.rendering_kw["color"] = s.line_color
+                    ax.add_patch(
+                        self.matplotlib.patches.Rectangle(
+                            *s.args, **s.rendering_kw))
+            else:
+                raise NotImplementedError(
+                    '{} is not supported in the SymPy plotting module '
+                    'with matplotlib backend. Please report this issue.'
+                    .format(ax))
+
+        Axes3D = mpl_toolkits.mplot3d.Axes3D
+        if not isinstance(ax, Axes3D):
+            ax.autoscale_view(
+                scalex=ax.get_autoscalex_on(),
+                scaley=ax.get_autoscaley_on())
+        else:
+            # XXX Workaround for matplotlib issue
+            # https://github.com/matplotlib/matplotlib/issues/17130
+            if xlims:
+                xlims = np.array(xlims)
+                xlim = (np.amin(xlims[:, 0]), np.amax(xlims[:, 1]))
+                ax.set_xlim(xlim)
+            else:
+                ax.set_xlim([0, 1])
+
+            if ylims:
+                ylims = np.array(ylims)
+                ylim = (np.amin(ylims[:, 0]), np.amax(ylims[:, 1]))
+                ax.set_ylim(ylim)
+            else:
+                ax.set_ylim([0, 1])
+
+            if zlims:
+                zlims = np.array(zlims)
+                zlim = (np.amin(zlims[:, 0]), np.amax(zlims[:, 1]))
+                ax.set_zlim(zlim)
+            else:
+                ax.set_zlim([0, 1])
+
+        # Set global options.
+        # TODO The 3D stuff
+        # XXX The order of those is important.
+        if self.xscale and not isinstance(ax, Axes3D):
+            ax.set_xscale(self.xscale)
+        if self.yscale and not isinstance(ax, Axes3D):
+            ax.set_yscale(self.yscale)
+        if not isinstance(ax, Axes3D) or self.matplotlib.__version__ >= '1.2.0':  # XXX in the distant future remove this check
+            ax.set_autoscale_on(self.autoscale)
+        if self.axis_center:
+            val = self.axis_center
+            if isinstance(ax, Axes3D):
+                pass
+            elif val == 'center':
+                ax.spines['left'].set_position('center')
+                ax.spines['bottom'].set_position('center')
+            elif val == 'auto':
+                xl, xh = ax.get_xlim()
+                yl, yh = ax.get_ylim()
+                pos_left = ('data', 0) if xl*xh <= 0 else 'center'
+                pos_bottom = ('data', 0) if yl*yh <= 0 else 'center'
+                ax.spines['left'].set_position(pos_left)
+                ax.spines['bottom'].set_position(pos_bottom)
+            else:
+                ax.spines['left'].set_position(('data', val[0]))
+                ax.spines['bottom'].set_position(('data', val[1]))
+        if not self.axis:
+            ax.set_axis_off()
+        if self.legend:
+            if ax.legend():
+                ax.legend_.set_visible(self.legend)
+        if self.margin:
+            ax.set_xmargin(self.margin)
+            ax.set_ymargin(self.margin)
+        if self.title:
+            ax.set_title(self.title)
+        if self.xlabel:
+            xlbl = _str_or_latex(self.xlabel)
+            ax.set_xlabel(xlbl, position=(1, 0))
+        if self.ylabel:
+            ylbl = _str_or_latex(self.ylabel)
+            ax.set_ylabel(ylbl, position=(0, 1))
+        if isinstance(ax, Axes3D) and self.zlabel:
+            zlbl = _str_or_latex(self.zlabel)
+            ax.set_zlabel(zlbl, position=(0, 1))
+
+        # xlim and ylim should always be set at last so that plot limits
+        # doesn't get altered during the process.
+        if self.xlim:
+            ax.set_xlim(self.xlim)
+        if self.ylim:
+            ax.set_ylim(self.ylim)
+        self.ax.set_aspect(self.aspect)
+
+
+    def process_series(self):
+        """
+        Iterates over every ``Plot`` object and further calls
+        _process_series()
+        """
+        self._create_figure()
+        self._process_series(self._series, self.ax)
+
+    def show(self):
+        self.process_series()
+        #TODO after fixing https://github.com/ipython/ipython/issues/1255
+        # you can uncomment the next line and remove the pyplot.show() call
+        #self.fig.show()
+        if base_backend._show:
+            self.fig.tight_layout()
+            self.plt.show()
+        else:
+            self.close()
+
+    def save(self, path):
+        self.process_series()
+        self.fig.savefig(path)
+
+    def close(self):
+        self.plt.close(self.fig)

venv/lib/python3.11/site-packages/sympy/plotting/backends/textbackend/__init__.py

@@ -0,0 +1,3 @@
+from sympy.plotting.backends.textbackend.text import TextBackend
+
+__all__ = ["TextBackend"]

venv/lib/python3.11/site-packages/sympy/plotting/backends/textbackend/text.py

@@ -0,0 +1,24 @@
+import sympy.plotting.backends.base_backend as base_backend
+from sympy.plotting.series import LineOver1DRangeSeries
+from sympy.plotting.textplot import textplot
+
+
+class TextBackend(base_backend.Plot):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def show(self):
+        if not base_backend._show:
+            return
+        if len(self._series) != 1:
+            raise ValueError(
+                'The TextBackend supports only one graph per Plot.')
+        elif not isinstance(self._series[0], LineOver1DRangeSeries):
+            raise ValueError(
+                'The TextBackend supports only expressions over a 1D range')
+        else:
+            ser = self._series[0]
+            textplot(ser.expr, ser.start, ser.end)
+
+    def close(self):
+        pass

venv/lib/python3.11/site-packages/sympy/plotting/experimental_lambdify.py

@@ -0,0 +1,641 @@
+""" rewrite of lambdify - This stuff is not stable at all.
+
+It is for internal use in the new plotting module.
+It may (will! see the Q'n'A in the source) be rewritten.
+
+It's completely self contained. Especially it does not use lambdarepr.
+
+It does not aim to replace the current lambdify. Most importantly it will never
+ever support anything else than SymPy expressions (no Matrices, dictionaries
+and so on).
+"""
+
+
+import re
+from sympy.core.numbers import (I, NumberSymbol, oo, zoo)
+from sympy.core.symbol import Symbol
+from sympy.utilities.iterables import numbered_symbols
+
+#  We parse the expression string into a tree that identifies functions. Then
+# we translate the names of the functions and we translate also some strings
+# that are not names of functions (all this according to translation
+# dictionaries).
+#  If the translation goes to another module (like numpy) the
+# module is imported and 'func' is translated to 'module.func'.
+#  If a function can not be translated, the inner nodes of that part of the
+# tree are not translated. So if we have Integral(sqrt(x)), sqrt is not
+# translated to np.sqrt and the Integral does not crash.
+#  A namespace for all this is generated by crawling the (func, args) tree of
+# the expression. The creation of this namespace involves many ugly
+# workarounds.
+#  The namespace consists of all the names needed for the SymPy expression and
+# all the name of modules used for translation. Those modules are imported only
+# as a name (import numpy as np) in order to keep the namespace small and
+# manageable.
+
+#  Please, if there is a bug, do not try to fix it here! Rewrite this by using
+# the method proposed in the last Q'n'A below. That way the new function will
+# work just as well, be just as simple, but it wont need any new workarounds.
+#  If you insist on fixing it here, look at the workarounds in the function
+# sympy_expression_namespace and in lambdify.
+
+# Q: Why are you not using Python abstract syntax tree?
+# A: Because it is more complicated and not much more powerful in this case.
+
+# Q: What if I have Symbol('sin') or g=Function('f')?
+# A: You will break the algorithm. We should use srepr to defend against this?
+#  The problem with Symbol('sin') is that it will be printed as 'sin'. The
+# parser will distinguish it from the function 'sin' because functions are
+# detected thanks to the opening parenthesis, but the lambda expression won't
+# understand the difference if we have also the sin function.
+# The solution (complicated) is to use srepr and maybe ast.
+#  The problem with the g=Function('f') is that it will be printed as 'f' but in
+# the global namespace we have only 'g'. But as the same printer is used in the
+# constructor of the namespace there will be no problem.
+
+# Q: What if some of the printers are not printing as expected?
+# A: The algorithm wont work. You must use srepr for those cases. But even
+# srepr may not print well. All problems with printers should be considered
+# bugs.
+
+# Q: What about _imp_ functions?
+# A: Those are taken care for by evalf. A special case treatment will work
+# faster but it's not worth the code complexity.
+
+# Q: Will ast fix all possible problems?
+# A: No. You will always have to use some printer. Even srepr may not work in
+# some cases. But if the printer does not work, that should be considered a
+# bug.
+
+# Q: Is there same way to fix all possible problems?
+# A: Probably by constructing our strings ourself by traversing the (func,
+# args) tree and creating the namespace at the same time. That actually sounds
+# good.
+
+from sympy.external import import_module
+import warnings
+
+#TODO debugging output
+
+
+class vectorized_lambdify:
+    """ Return a sufficiently smart, vectorized and lambdified function.
+
+    Returns only reals.
+
+    Explanation
+    ===========
+
+    This function uses experimental_lambdify to created a lambdified
+    expression ready to be used with numpy. Many of the functions in SymPy
+    are not implemented in numpy so in some cases we resort to Python cmath or
+    even to evalf.
+
+    The following translations are tried:
+      only numpy complex
+      - on errors raised by SymPy trying to work with ndarray:
+          only Python cmath and then vectorize complex128
+
+    When using Python cmath there is no need for evalf or float/complex
+    because Python cmath calls those.
+
+    This function never tries to mix numpy directly with evalf because numpy
+    does not understand SymPy Float. If this is needed one can use the
+    float_wrap_evalf/complex_wrap_evalf options of experimental_lambdify or
+    better one can be explicit about the dtypes that numpy works with.
+    Check numpy bug http://projects.scipy.org/numpy/ticket/1013 to know what
+    types of errors to expect.
+    """
+    def __init__(self, args, expr):
+        self.args = args
+        self.expr = expr
+        self.np = import_module('numpy')
+
+        self.lambda_func_1 = experimental_lambdify(
+            args, expr, use_np=True)
+        self.vector_func_1 = self.lambda_func_1
+
+        self.lambda_func_2 = experimental_lambdify(
+            args, expr, use_python_cmath=True)
+        self.vector_func_2 = self.np.vectorize(
+            self.lambda_func_2, otypes=[complex])
+
+        self.vector_func = self.vector_func_1
+        self.failure = False
+
+    def __call__(self, *args):
+        np = self.np
+
+        try:
+            temp_args = (np.array(a, dtype=complex) for a in args)
+            results = self.vector_func(*temp_args)
+            results = np.ma.masked_where(
+                np.abs(results.imag) > 1e-7 * np.abs(results),
+                results.real, copy=False)
+            return results
+        except ValueError:
+            if self.failure:
+                raise
+
+            self.failure = True
+            self.vector_func = self.vector_func_2
+            warnings.warn(
+                'The evaluation of the expression is problematic. '
+                'We are trying a failback method that may still work. '
+                'Please report this as a bug.')
+            return self.__call__(*args)
+
+
+class lambdify:
+    """Returns the lambdified function.
+
+    Explanation
+    ===========
+
+    This function uses experimental_lambdify to create a lambdified
+    expression. It uses cmath to lambdify the expression. If the function
+    is not implemented in Python cmath, Python cmath calls evalf on those
+    functions.
+    """
+
+    def __init__(self, args, expr):
+        self.args = args
+        self.expr = expr
+        self.lambda_func_1 = experimental_lambdify(
+            args, expr, use_python_cmath=True, use_evalf=True)
+        self.lambda_func_2 = experimental_lambdify(
+            args, expr, use_python_math=True, use_evalf=True)
+        self.lambda_func_3 = experimental_lambdify(
+            args, expr, use_evalf=True, complex_wrap_evalf=True)
+        self.lambda_func = self.lambda_func_1
+        self.failure = False
+
+    def __call__(self, args):
+        try:
+            #The result can be sympy.Float. Hence wrap it with complex type.
+            result = complex(self.lambda_func(args))
+            if abs(result.imag) > 1e-7 * abs(result):
+                return None
+            return result.real
+        except (ZeroDivisionError, OverflowError):
+            return None
+        except TypeError as e:
+            if self.failure:
+                raise e
+
+            if self.lambda_func == self.lambda_func_1:
+                self.lambda_func = self.lambda_func_2
+                return self.__call__(args)
+
+            self.failure = True
+            self.lambda_func = self.lambda_func_3
+            warnings.warn(
+                'The evaluation of the expression is problematic. '
+                'We are trying a failback method that may still work. '
+                'Please report this as a bug.', stacklevel=2)
+            return self.__call__(args)
+
+
+def experimental_lambdify(*args, **kwargs):
+    l = Lambdifier(*args, **kwargs)
+    return l
+
+
+class Lambdifier:
+    def __init__(self, args, expr, print_lambda=False, use_evalf=False,
+                 float_wrap_evalf=False, complex_wrap_evalf=False,
+                 use_np=False, use_python_math=False, use_python_cmath=False,
+                 use_interval=False):
+
+        self.print_lambda = print_lambda
+        self.use_evalf = use_evalf
+        self.float_wrap_evalf = float_wrap_evalf
+        self.complex_wrap_evalf = complex_wrap_evalf
+        self.use_np = use_np
+        self.use_python_math = use_python_math
+        self.use_python_cmath = use_python_cmath
+        self.use_interval = use_interval
+
+        # Constructing the argument string
+        # - check
+        if not all(isinstance(a, Symbol) for a in args):
+            raise ValueError('The arguments must be Symbols.')
+        # - use numbered symbols
+        syms = numbered_symbols(exclude=expr.free_symbols)
+        newargs = [next(syms) for _ in args]
+        expr = expr.xreplace(dict(zip(args, newargs)))
+        argstr = ', '.join([str(a) for a in newargs])
+        del syms, newargs, args
+
+        # Constructing the translation dictionaries and making the translation
+        self.dict_str = self.get_dict_str()
+        self.dict_fun = self.get_dict_fun()
+        exprstr = str(expr)
+        newexpr = self.tree2str_translate(self.str2tree(exprstr))
+
+        # Constructing the namespaces
+        namespace = {}
+        namespace.update(self.sympy_atoms_namespace(expr))
+        namespace.update(self.sympy_expression_namespace(expr))
+        # XXX Workaround
+        # Ugly workaround because Pow(a,Half) prints as sqrt(a)
+        # and sympy_expression_namespace can not catch it.
+        from sympy.functions.elementary.miscellaneous import sqrt
+        namespace.update({'sqrt': sqrt})
+        namespace.update({'Eq': lambda x, y: x == y})
+        namespace.update({'Ne': lambda x, y: x != y})
+        # End workaround.
+        if use_python_math:
+            namespace.update({'math': __import__('math')})
+        if use_python_cmath:
+            namespace.update({'cmath': __import__('cmath')})
+        if use_np:
+            try:
+                namespace.update({'np': __import__('numpy')})
+            except ImportError:
+                raise ImportError(
+                    'experimental_lambdify failed to import numpy.')
+        if use_interval:
+            namespace.update({'imath': __import__(
+                'sympy.plotting.intervalmath', fromlist=['intervalmath'])})
+            namespace.update({'math': __import__('math')})
+
+        # Construct the lambda
+        if self.print_lambda:
+            print(newexpr)
+        eval_str = 'lambda %s : ( %s )' % (argstr, newexpr)
+        self.eval_str = eval_str
+        exec("MYNEWLAMBDA = %s" % eval_str, namespace)
+        self.lambda_func = namespace['MYNEWLAMBDA']
+
+    def __call__(self, *args, **kwargs):
+        return self.lambda_func(*args, **kwargs)
+
+
+    ##############################################################################
+    # Dicts for translating from SymPy to other modules
+    ##############################################################################
+    ###
+    # builtins
+    ###
+    # Functions with different names in builtins
+    builtin_functions_different = {
+        'Min': 'min',
+        'Max': 'max',
+        'Abs': 'abs',
+    }
+
+    # Strings that should be translated
+    builtin_not_functions = {
+        'I': '1j',
+#        'oo': '1e400',
+    }
+
+    ###
+    # numpy
+    ###
+
+    # Functions that are the same in numpy
+    numpy_functions_same = [
+        'sin', 'cos', 'tan', 'sinh', 'cosh', 'tanh', 'exp', 'log',
+        'sqrt', 'floor', 'conjugate', 'sign',
+    ]
+
+    # Functions with different names in numpy
+    numpy_functions_different = {
+        "acos": "arccos",
+        "acosh": "arccosh",
+        "arg": "angle",
+        "asin": "arcsin",
+        "asinh": "arcsinh",
+        "atan": "arctan",
+        "atan2": "arctan2",
+        "atanh": "arctanh",
+        "ceiling": "ceil",
+        "im": "imag",
+        "ln": "log",
+        "Max": "amax",
+        "Min": "amin",
+        "re": "real",
+        "Abs": "abs",
+    }
+
+    # Strings that should be translated
+    numpy_not_functions = {
+        'pi': 'np.pi',
+        'oo': 'np.inf',
+        'E': 'np.e',
+    }
+
+    ###
+    # Python math
+    ###
+
+    # Functions that are the same in math
+    math_functions_same = [
+        'sin', 'cos', 'tan', 'asin', 'acos', 'atan', 'atan2',
+        'sinh', 'cosh', 'tanh', 'asinh', 'acosh', 'atanh',
+        'exp', 'log', 'erf', 'sqrt', 'floor', 'factorial', 'gamma',
+    ]
+
+    # Functions with different names in math
+    math_functions_different = {
+        'ceiling': 'ceil',
+        'ln': 'log',
+        'loggamma': 'lgamma'
+    }
+
+    # Strings that should be translated
+    math_not_functions = {
+        'pi': 'math.pi',
+        'E': 'math.e',
+    }
+
+    ###
+    # Python cmath
+    ###
+
+    # Functions that are the same in cmath
+    cmath_functions_same = [
+        'sin', 'cos', 'tan', 'asin', 'acos', 'atan',
+        'sinh', 'cosh', 'tanh', 'asinh', 'acosh', 'atanh',
+        'exp', 'log', 'sqrt',
+    ]
+
+    # Functions with different names in cmath
+    cmath_functions_different = {
+        'ln': 'log',
+        'arg': 'phase',
+    }
+
+    # Strings that should be translated
+    cmath_not_functions = {
+        'pi': 'cmath.pi',
+        'E': 'cmath.e',
+    }
+
+    ###
+    # intervalmath
+    ###
+
+    interval_not_functions = {
+        'pi': 'math.pi',
+        'E': 'math.e'
+    }
+
+    interval_functions_same = [
+        'sin', 'cos', 'exp', 'tan', 'atan', 'log',
+        'sqrt', 'cosh', 'sinh', 'tanh', 'floor',
+        'acos', 'asin', 'acosh', 'asinh', 'atanh',
+        'Abs', 'And', 'Or'
+    ]
+
+    interval_functions_different = {
+        'Min': 'imin',
+        'Max': 'imax',
+        'ceiling': 'ceil',
+
+    }
+
+    ###
+    # mpmath, etc
+    ###
+    #TODO
+
+    ###
+    # Create the final ordered tuples of dictionaries
+    ###
+
+    # For strings
+    def get_dict_str(self):
+        dict_str = dict(self.builtin_not_functions)
+        if self.use_np:
+            dict_str.update(self.numpy_not_functions)
+        if self.use_python_math:
+            dict_str.update(self.math_not_functions)
+        if self.use_python_cmath:
+            dict_str.update(self.cmath_not_functions)
+        if self.use_interval:
+            dict_str.update(self.interval_not_functions)
+        return dict_str
+
+    # For functions
+    def get_dict_fun(self):
+        dict_fun = dict(self.builtin_functions_different)
+        if self.use_np:
+            for s in self.numpy_functions_same:
+                dict_fun[s] = 'np.' + s
+            for k, v in self.numpy_functions_different.items():
+                dict_fun[k] = 'np.' + v
+        if self.use_python_math:
+            for s in self.math_functions_same:
+                dict_fun[s] = 'math.' + s
+            for k, v in self.math_functions_different.items():
+                dict_fun[k] = 'math.' + v
+        if self.use_python_cmath:
+            for s in self.cmath_functions_same:
+                dict_fun[s] = 'cmath.' + s
+            for k, v in self.cmath_functions_different.items():
+                dict_fun[k] = 'cmath.' + v
+        if self.use_interval:
+            for s in self.interval_functions_same:
+                dict_fun[s] = 'imath.' + s
+            for k, v in self.interval_functions_different.items():
+                dict_fun[k] = 'imath.' + v
+        return dict_fun
+
+    ##############################################################################
+    # The translator functions, tree parsers, etc.
+    ##############################################################################
+
+    def str2tree(self, exprstr):
+        """Converts an expression string to a tree.
+
+        Explanation
+        ===========
+
+        Functions are represented by ('func_name(', tree_of_arguments).
+        Other expressions are (head_string, mid_tree, tail_str).
+        Expressions that do not contain functions are directly returned.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y, z
+        >>> from sympy import Integral, sin
+        >>> from sympy.plotting.experimental_lambdify import Lambdifier
+        >>> str2tree = Lambdifier([x], x).str2tree
+
+        >>> str2tree(str(Integral(x, (x, 1, y))))
+        ('', ('Integral(', 'x, (x, 1, y)'), ')')
+        >>> str2tree(str(x+y))
+        'x + y'
+        >>> str2tree(str(x+y*sin(z)+1))
+        ('x + y*', ('sin(', 'z'), ') + 1')
+        >>> str2tree('sin(y*(y + 1.1) + (sin(y)))')
+        ('', ('sin(', ('y*(y + 1.1) + (', ('sin(', 'y'), '))')), ')')
+        """
+        #matches the first 'function_name('
+        first_par = re.search(r'(\w+\()', exprstr)
+        if first_par is None:
+            return exprstr
+        else:
+            start = first_par.start()
+            end = first_par.end()
+            head = exprstr[:start]
+            func = exprstr[start:end]
+            tail = exprstr[end:]
+            count = 0
+            for i, c in enumerate(tail):
+                if c == '(':
+                    count += 1
+                elif c == ')':
+                    count -= 1
+                if count == -1:
+                    break
+            func_tail = self.str2tree(tail[:i])
+            tail = self.str2tree(tail[i:])
+            return (head, (func, func_tail), tail)
+
+    @classmethod
+    def tree2str(cls, tree):
+        """Converts a tree to string without translations.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y, z
+        >>> from sympy import sin
+        >>> from sympy.plotting.experimental_lambdify import Lambdifier
+        >>> str2tree = Lambdifier([x], x).str2tree
+        >>> tree2str = Lambdifier([x], x).tree2str
+
+        >>> tree2str(str2tree(str(x+y*sin(z)+1)))
+        'x + y*sin(z) + 1'
+        """
+        if isinstance(tree, str):
+            return tree
+        else:
+            return ''.join(map(cls.tree2str, tree))
+
+    def tree2str_translate(self, tree):
+        """Converts a tree to string with translations.
+
+        Explanation
+        ===========
+
+        Function names are translated by translate_func.
+        Other strings are translated by translate_str.
+        """
+        if isinstance(tree, str):
+            return self.translate_str(tree)
+        elif isinstance(tree, tuple) and len(tree) == 2:
+            return self.translate_func(tree[0][:-1], tree[1])
+        else:
+            return ''.join([self.tree2str_translate(t) for t in tree])
+
+    def translate_str(self, estr):
+        """Translate substrings of estr using in order the dictionaries in
+        dict_tuple_str."""
+        for pattern, repl in self.dict_str.items():
+                estr = re.sub(pattern, repl, estr)
+        return estr
+
+    def translate_func(self, func_name, argtree):
+        """Translate function names and the tree of arguments.
+
+        Explanation
+        ===========
+
+        If the function name is not in the dictionaries of dict_tuple_fun then the
+        function is surrounded by a float((...).evalf()).
+
+        The use of float is necessary as np.<function>(sympy.Float(..)) raises an
+        error."""
+        if func_name in self.dict_fun:
+            new_name = self.dict_fun[func_name]
+            argstr = self.tree2str_translate(argtree)
+            return new_name + '(' + argstr
+        elif func_name in ['Eq', 'Ne']:
+            op = {'Eq': '==', 'Ne': '!='}
+            return "(lambda x, y: x {} y)({}".format(op[func_name], self.tree2str_translate(argtree))
+        else:
+            template = '(%s(%s)).evalf(' if self.use_evalf else '%s(%s'
+            if self.float_wrap_evalf:
+                template = 'float(%s)' % template
+            elif self.complex_wrap_evalf:
+                template = 'complex(%s)' % template
+
+            # Wrapping should only happen on the outermost expression, which
+            # is the only thing we know will be a number.
+            float_wrap_evalf = self.float_wrap_evalf
+            complex_wrap_evalf = self.complex_wrap_evalf
+            self.float_wrap_evalf = False
+            self.complex_wrap_evalf = False
+            ret =  template % (func_name, self.tree2str_translate(argtree))
+            self.float_wrap_evalf = float_wrap_evalf
+            self.complex_wrap_evalf = complex_wrap_evalf
+            return ret
+
+    ##############################################################################
+    # The namespace constructors
+    ##############################################################################
+
+    @classmethod
+    def sympy_expression_namespace(cls, expr):
+        """Traverses the (func, args) tree of an expression and creates a SymPy
+        namespace. All other modules are imported only as a module name. That way
+        the namespace is not polluted and rests quite small. It probably causes much
+        more variable lookups and so it takes more time, but there are no tests on
+        that for the moment."""
+        if expr is None:
+            return {}
+        else:
+            funcname = str(expr.func)
+            # XXX Workaround
+            # Here we add an ugly workaround because str(func(x))
+            # is not always the same as str(func). Eg
+            # >>> str(Integral(x))
+            # "Integral(x)"
+            # >>> str(Integral)
+            # "<class 'sympy.integrals.integrals.Integral'>"
+            # >>> str(sqrt(x))
+            # "sqrt(x)"
+            # >>> str(sqrt)
+            # "<function sqrt at 0x3d92de8>"
+            # >>> str(sin(x))
+            # "sin(x)"
+            # >>> str(sin)
+            # "sin"
+            # Either one of those can be used but not all at the same time.
+            # The code considers the sin example as the right one.
+            regexlist = [
+                r'<class \'sympy[\w.]*?.([\w]*)\'>$',
+                # the example Integral
+                r'<function ([\w]*) at 0x[\w]*>$',    # the example sqrt
+            ]
+            for r in regexlist:
+                m = re.match(r, funcname)
+                if m is not None:
+                    funcname = m.groups()[0]
+            # End of the workaround
+            # XXX debug: print funcname
+            args_dict = {}
+            for a in expr.args:
+                if (isinstance(a, (Symbol, NumberSymbol)) or a in [I, zoo, oo]):
+                    continue
+                else:
+                    args_dict.update(cls.sympy_expression_namespace(a))
+            args_dict.update({funcname: expr.func})
+            return args_dict
+
+    @staticmethod
+    def sympy_atoms_namespace(expr):
+        """For no real reason this function is separated from
+        sympy_expression_namespace. It can be moved to it."""
+        atoms = expr.atoms(Symbol, NumberSymbol, I, zoo, oo)
+        d = {}
+        for a in atoms:
+            # XXX debug: print 'atom:' + str(a)
+            d[str(a)] = a
+        return d

venv/lib/python3.11/site-packages/sympy/plotting/intervalmath/__init__.py

@@ -0,0 +1,12 @@
+from .interval_arithmetic import interval
+from .lib_interval import (Abs, exp, log, log10, sin, cos, tan, sqrt,
+                          imin, imax, sinh, cosh, tanh, acosh, asinh, atanh,
+                          asin, acos, atan, ceil, floor, And, Or)
+
+__all__ = [
+    'interval',
+
+    'Abs', 'exp', 'log', 'log10', 'sin', 'cos', 'tan', 'sqrt', 'imin', 'imax',
+    'sinh', 'cosh', 'tanh', 'acosh', 'asinh', 'atanh', 'asin', 'acos', 'atan',
+    'ceil', 'floor', 'And', 'Or',
+]

venv/lib/python3.11/site-packages/sympy/plotting/intervalmath/interval_arithmetic.py

@@ -0,0 +1,413 @@
+"""
+Interval Arithmetic for plotting.
+This module does not implement interval arithmetic accurately and
+hence cannot be used for purposes other than plotting. If you want
+to use interval arithmetic, use mpmath's interval arithmetic.
+
+The module implements interval arithmetic using numpy and
+python floating points. The rounding up and down is not handled
+and hence this is not an accurate implementation of interval
+arithmetic.
+
+The module uses numpy for speed which cannot be achieved with mpmath.
+"""
+
+# Q: Why use numpy? Why not simply use mpmath's interval arithmetic?
+# A: mpmath's interval arithmetic simulates a floating point unit
+# and hence is slow, while numpy evaluations are orders of magnitude
+# faster.
+
+# Q: Why create a separate class for intervals? Why not use SymPy's
+# Interval Sets?
+# A: The functionalities that will be required for plotting is quite
+# different from what Interval Sets implement.
+
+# Q: Why is rounding up and down according to IEEE754 not handled?
+# A: It is not possible to do it in both numpy and python. An external
+# library has to used, which defeats the whole purpose i.e., speed. Also
+# rounding is handled for very few functions in those libraries.
+
+# Q Will my plots be affected?
+# A It will not affect most of the plots. The interval arithmetic
+# module based suffers the same problems as that of floating point
+# arithmetic.
+
+from sympy.core.numbers import int_valued
+from sympy.core.logic import fuzzy_and
+from sympy.simplify.simplify import nsimplify
+
+from .interval_membership import intervalMembership
+
+
+class interval:
+    """ Represents an interval containing floating points as start and
+    end of the interval
+    The is_valid variable tracks whether the interval obtained as the
+    result of the function is in the domain and is continuous.
+    - True: Represents the interval result of a function is continuous and
+            in the domain of the function.
+    - False: The interval argument of the function was not in the domain of
+             the function, hence the is_valid of the result interval is False
+    - None: The function was not continuous over the interval or
+            the function's argument interval is partly in the domain of the
+            function
+
+    A comparison between an interval and a real number, or a
+    comparison between two intervals may return ``intervalMembership``
+    of two 3-valued logic values.
+    """
+
+    def __init__(self, *args, is_valid=True, **kwargs):
+        self.is_valid = is_valid
+        if len(args) == 1:
+            if isinstance(args[0], interval):
+                self.start, self.end = args[0].start, args[0].end
+            else:
+                self.start = float(args[0])
+                self.end = float(args[0])
+        elif len(args) == 2:
+            if args[0] < args[1]:
+                self.start = float(args[0])
+                self.end = float(args[1])
+            else:
+                self.start = float(args[1])
+                self.end = float(args[0])
+
+        else:
+            raise ValueError("interval takes a maximum of two float values "
+                            "as arguments")
+
+    @property
+    def mid(self):
+        return (self.start + self.end) / 2.0
+
+    @property
+    def width(self):
+        return self.end - self.start
+
+    def __repr__(self):
+        return "interval(%f, %f)" % (self.start, self.end)
+
+    def __str__(self):
+        return "[%f, %f]" % (self.start, self.end)
+
+    def __lt__(self, other):
+        if isinstance(other, (int, float)):
+            if self.end < other:
+                return intervalMembership(True, self.is_valid)
+            elif self.start > other:
+                return intervalMembership(False, self.is_valid)
+            else:
+                return intervalMembership(None, self.is_valid)
+
+        elif isinstance(other, interval):
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            if self.end < other. start:
+                return intervalMembership(True, valid)
+            if self.start > other.end:
+                return intervalMembership(False, valid)
+            return intervalMembership(None, valid)
+        else:
+            return NotImplemented
+
+    def __gt__(self, other):
+        if isinstance(other, (int, float)):
+            if self.start > other:
+                return intervalMembership(True, self.is_valid)
+            elif self.end < other:
+                return intervalMembership(False, self.is_valid)
+            else:
+                return intervalMembership(None, self.is_valid)
+        elif isinstance(other, interval):
+            return other.__lt__(self)
+        else:
+            return NotImplemented
+
+    def __eq__(self, other):
+        if isinstance(other, (int, float)):
+            if self.start == other and self.end == other:
+                return intervalMembership(True, self.is_valid)
+            if other in self:
+                return intervalMembership(None, self.is_valid)
+            else:
+                return intervalMembership(False, self.is_valid)
+
+        if isinstance(other, interval):
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            if self.start == other.start and self.end == other.end:
+                return intervalMembership(True, valid)
+            elif self.__lt__(other)[0] is not None:
+                return intervalMembership(False, valid)
+            else:
+                return intervalMembership(None, valid)
+        else:
+            return NotImplemented
+
+    def __ne__(self, other):
+        if isinstance(other, (int, float)):
+            if self.start == other and self.end == other:
+                return intervalMembership(False, self.is_valid)
+            if other in self:
+                return intervalMembership(None, self.is_valid)
+            else:
+                return intervalMembership(True, self.is_valid)
+
+        if isinstance(other, interval):
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            if self.start == other.start and self.end == other.end:
+                return intervalMembership(False, valid)
+            if not self.__lt__(other)[0] is None:
+                return intervalMembership(True, valid)
+            return intervalMembership(None, valid)
+        else:
+            return NotImplemented
+
+    def __le__(self, other):
+        if isinstance(other, (int, float)):
+            if self.end <= other:
+                return intervalMembership(True, self.is_valid)
+            if self.start > other:
+                return intervalMembership(False, self.is_valid)
+            else:
+                return intervalMembership(None, self.is_valid)
+
+        if isinstance(other, interval):
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            if self.end <= other.start:
+                return intervalMembership(True, valid)
+            if self.start > other.end:
+                return intervalMembership(False, valid)
+            return intervalMembership(None, valid)
+        else:
+            return NotImplemented
+
+    def __ge__(self, other):
+        if isinstance(other, (int, float)):
+            if self.start >= other:
+                return intervalMembership(True, self.is_valid)
+            elif self.end < other:
+                return intervalMembership(False, self.is_valid)
+            else:
+                return intervalMembership(None, self.is_valid)
+        elif isinstance(other, interval):
+            return other.__le__(self)
+
+    def __add__(self, other):
+        if isinstance(other, (int, float)):
+            if self.is_valid:
+                return interval(self.start + other, self.end + other)
+            else:
+                start = self.start + other
+                end = self.end + other
+                return interval(start, end, is_valid=self.is_valid)
+
+        elif isinstance(other, interval):
+            start = self.start + other.start
+            end = self.end + other.end
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            return interval(start, end, is_valid=valid)
+        else:
+            return NotImplemented
+
+    __radd__ = __add__
+
+    def __sub__(self, other):
+        if isinstance(other, (int, float)):
+            start = self.start - other
+            end = self.end - other
+            return interval(start, end, is_valid=self.is_valid)
+
+        elif isinstance(other, interval):
+            start = self.start - other.end
+            end = self.end - other.start
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            return interval(start, end, is_valid=valid)
+        else:
+            return NotImplemented
+
+    def __rsub__(self, other):
+        if isinstance(other, (int, float)):
+            start = other - self.end
+            end = other - self.start
+            return interval(start, end, is_valid=self.is_valid)
+        elif isinstance(other, interval):
+            return other.__sub__(self)
+        else:
+            return NotImplemented
+
+    def __neg__(self):
+        if self.is_valid:
+            return interval(-self.end, -self.start)
+        else:
+            return interval(-self.end, -self.start, is_valid=self.is_valid)
+
+    def __mul__(self, other):
+        if isinstance(other, interval):
+            if self.is_valid is False or other.is_valid is False:
+                return interval(-float('inf'), float('inf'), is_valid=False)
+            elif self.is_valid is None or other.is_valid is None:
+                return interval(-float('inf'), float('inf'), is_valid=None)
+            else:
+                inters = []
+                inters.append(self.start * other.start)
+                inters.append(self.end * other.start)
+                inters.append(self.start * other.end)
+                inters.append(self.end * other.end)
+                start = min(inters)
+                end = max(inters)
+                return interval(start, end)
+        elif isinstance(other, (int, float)):
+            return interval(self.start*other, self.end*other, is_valid=self.is_valid)
+        else:
+            return NotImplemented
+
+    __rmul__ = __mul__
+
+    def __contains__(self, other):
+        if isinstance(other, (int, float)):
+            return self.start <= other and self.end >= other
+        else:
+            return self.start <= other.start and other.end <= self.end
+
+    def __rtruediv__(self, other):
+        if isinstance(other, (int, float)):
+            other = interval(other)
+            return other.__truediv__(self)
+        elif isinstance(other, interval):
+            return other.__truediv__(self)
+        else:
+            return NotImplemented
+
+    def __truediv__(self, other):
+        # Both None and False are handled
+        if not self.is_valid:
+            # Don't divide as the value is not valid
+            return interval(-float('inf'), float('inf'), is_valid=self.is_valid)
+        if isinstance(other, (int, float)):
+            if other == 0:
+                # Divide by zero encountered. valid nowhere
+                return interval(-float('inf'), float('inf'), is_valid=False)
+            else:
+                return interval(self.start / other, self.end / other)
+
+        elif isinstance(other, interval):
+            if other.is_valid is False or self.is_valid is False:
+                return interval(-float('inf'), float('inf'), is_valid=False)
+            elif other.is_valid is None or self.is_valid is None:
+                return interval(-float('inf'), float('inf'), is_valid=None)
+            else:
+               # denominator contains both signs, i.e. being divided by zero
+               # return the whole real line with is_valid = None
+                if 0 in other:
+                    return interval(-float('inf'), float('inf'), is_valid=None)
+
+                # denominator negative
+                this = self
+                if other.end < 0:
+                    this = -this
+                    other = -other
+
+                # denominator positive
+                inters = []
+                inters.append(this.start / other.start)
+                inters.append(this.end / other.start)
+                inters.append(this.start / other.end)
+                inters.append(this.end / other.end)
+                start = max(inters)
+                end = min(inters)
+                return interval(start, end)
+        else:
+            return NotImplemented
+
+    def __pow__(self, other):
+        # Implements only power to an integer.
+        from .lib_interval import exp, log
+        if not self.is_valid:
+            return self
+        if isinstance(other, interval):
+            return exp(other * log(self))
+        elif isinstance(other, (float, int)):
+            if other < 0:
+                return 1 / self.__pow__(abs(other))
+            else:
+                if int_valued(other):
+                    return _pow_int(self, other)
+                else:
+                    return _pow_float(self, other)
+        else:
+            return NotImplemented
+
+    def __rpow__(self, other):
+        if isinstance(other, (float, int)):
+            if not self.is_valid:
+                #Don't do anything
+                return self
+            elif other < 0:
+                if self.width > 0:
+                    return interval(-float('inf'), float('inf'), is_valid=False)
+                else:
+                    power_rational = nsimplify(self.start)
+                    num, denom = power_rational.as_numer_denom()
+                    if denom % 2 == 0:
+                        return interval(-float('inf'), float('inf'),
+                                        is_valid=False)
+                    else:
+                        start = -abs(other)**self.start
+                        end = start
+                        return interval(start, end)
+            else:
+                return interval(other**self.start, other**self.end)
+        elif isinstance(other, interval):
+            return other.__pow__(self)
+        else:
+            return NotImplemented
+
+    def __hash__(self):
+        return hash((self.is_valid, self.start, self.end))
+
+
+def _pow_float(inter, power):
+    """Evaluates an interval raised to a floating point."""
+    power_rational = nsimplify(power)
+    num, denom = power_rational.as_numer_denom()
+    if num % 2 == 0:
+        start = abs(inter.start)**power
+        end = abs(inter.end)**power
+        if start < 0:
+            ret = interval(0, max(start, end))
+        else:
+            ret = interval(start, end)
+        return ret
+    elif denom % 2 == 0:
+        if inter.end < 0:
+            return interval(-float('inf'), float('inf'), is_valid=False)
+        elif inter.start < 0:
+            return interval(0, inter.end**power, is_valid=None)
+        else:
+            return interval(inter.start**power, inter.end**power)
+    else:
+        if inter.start < 0:
+            start = -abs(inter.start)**power
+        else:
+            start = inter.start**power
+
+        if inter.end < 0:
+            end = -abs(inter.end)**power
+        else:
+            end = inter.end**power
+
+        return interval(start, end, is_valid=inter.is_valid)
+
+
+def _pow_int(inter, power):
+    """Evaluates an interval raised to an integer power"""
+    power = int(power)
+    if power & 1:
+        return interval(inter.start**power, inter.end**power)
+    else:
+        if inter.start < 0 and inter.end > 0:
+            start = 0
+            end = max(inter.start**power, inter.end**power)
+            return interval(start, end)
+        else:
+            return interval(inter.start**power, inter.end**power)

venv/lib/python3.11/site-packages/sympy/plotting/intervalmath/interval_membership.py

@@ -0,0 +1,78 @@
+from sympy.core.logic import fuzzy_and, fuzzy_or, fuzzy_not, fuzzy_xor
+
+
+class intervalMembership:
+    """Represents a boolean expression returned by the comparison of
+    the interval object.
+
+    Parameters
+    ==========
+
+    (a, b) : (bool, bool)
+        The first value determines the comparison as follows:
+        - True: If the comparison is True throughout the intervals.
+        - False: If the comparison is False throughout the intervals.
+        - None: If the comparison is True for some part of the intervals.
+
+        The second value is determined as follows:
+        - True: If both the intervals in comparison are valid.
+        - False: If at least one of the intervals is False, else
+        - None
+    """
+    def __init__(self, a, b):
+        self._wrapped = (a, b)
+
+    def __getitem__(self, i):
+        try:
+            return self._wrapped[i]
+        except IndexError:
+            raise IndexError(
+                "{} must be a valid indexing for the 2-tuple."
+                .format(i))
+
+    def __len__(self):
+        return 2
+
+    def __iter__(self):
+        return iter(self._wrapped)
+
+    def __str__(self):
+        return "intervalMembership({}, {})".format(*self)
+    __repr__ = __str__
+
+    def __and__(self, other):
+        if not isinstance(other, intervalMembership):
+            raise ValueError(
+                "The comparison is not supported for {}.".format(other))
+
+        a1, b1 = self
+        a2, b2 = other
+        return intervalMembership(fuzzy_and([a1, a2]), fuzzy_and([b1, b2]))
+
+    def __or__(self, other):
+        if not isinstance(other, intervalMembership):
+            raise ValueError(
+                "The comparison is not supported for {}.".format(other))
+
+        a1, b1 = self
+        a2, b2 = other
+        return intervalMembership(fuzzy_or([a1, a2]), fuzzy_and([b1, b2]))
+
+    def __invert__(self):
+        a, b = self
+        return intervalMembership(fuzzy_not(a), b)
+
+    def __xor__(self, other):
+        if not isinstance(other, intervalMembership):
+            raise ValueError(
+                "The comparison is not supported for {}.".format(other))
+
+        a1, b1 = self
+        a2, b2 = other
+        return intervalMembership(fuzzy_xor([a1, a2]), fuzzy_and([b1, b2]))
+
+    def __eq__(self, other):
+        return self._wrapped == other
+
+    def __ne__(self, other):
+        return self._wrapped != other

venv/lib/python3.11/site-packages/sympy/plotting/intervalmath/lib_interval.py

@@ -0,0 +1,452 @@
+""" The module contains implemented functions for interval arithmetic."""
+from functools import reduce
+
+from sympy.plotting.intervalmath import interval
+from sympy.external import import_module
+
+
+def Abs(x):
+    if isinstance(x, (int, float)):
+        return interval(abs(x))
+    elif isinstance(x, interval):
+        if x.start < 0 and x.end > 0:
+            return interval(0, max(abs(x.start), abs(x.end)), is_valid=x.is_valid)
+        else:
+            return interval(abs(x.start), abs(x.end))
+    else:
+        raise NotImplementedError
+
+#Monotonic
+
+
+def exp(x):
+    """evaluates the exponential of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.exp(x), np.exp(x))
+    elif isinstance(x, interval):
+        return interval(np.exp(x.start), np.exp(x.end), is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+#Monotonic
+def log(x):
+    """evaluates the natural logarithm of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        if x <= 0:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            return interval(np.log(x))
+    elif isinstance(x, interval):
+        if not x.is_valid:
+            return interval(-np.inf, np.inf, is_valid=x.is_valid)
+        elif x.end <= 0:
+            return interval(-np.inf, np.inf, is_valid=False)
+        elif x.start <= 0:
+            return interval(-np.inf, np.inf, is_valid=None)
+
+        return interval(np.log(x.start), np.log(x.end))
+    else:
+        raise NotImplementedError
+
+
+#Monotonic
+def log10(x):
+    """evaluates the logarithm to the base 10 of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        if x <= 0:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            return interval(np.log10(x))
+    elif isinstance(x, interval):
+        if not x.is_valid:
+            return interval(-np.inf, np.inf, is_valid=x.is_valid)
+        elif x.end <= 0:
+            return interval(-np.inf, np.inf, is_valid=False)
+        elif x.start <= 0:
+            return interval(-np.inf, np.inf, is_valid=None)
+        return interval(np.log10(x.start), np.log10(x.end))
+    else:
+        raise NotImplementedError
+
+
+#Monotonic
+def atan(x):
+    """evaluates the tan inverse of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.arctan(x))
+    elif isinstance(x, interval):
+        start = np.arctan(x.start)
+        end = np.arctan(x.end)
+        return interval(start, end, is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+#periodic
+def sin(x):
+    """evaluates the sine of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.sin(x))
+    elif isinstance(x, interval):
+        if not x.is_valid:
+            return interval(-1, 1, is_valid=x.is_valid)
+        na, __ = divmod(x.start, np.pi / 2.0)
+        nb, __ = divmod(x.end, np.pi / 2.0)
+        start = min(np.sin(x.start), np.sin(x.end))
+        end = max(np.sin(x.start), np.sin(x.end))
+        if nb - na > 4:
+            return interval(-1, 1, is_valid=x.is_valid)
+        elif na == nb:
+            return interval(start, end, is_valid=x.is_valid)
+        else:
+            if (na - 1) // 4 != (nb - 1) // 4:
+                #sin has max
+                end = 1
+            if (na - 3) // 4 != (nb - 3) // 4:
+                #sin has min
+                start = -1
+            return interval(start, end)
+    else:
+        raise NotImplementedError
+
+
+#periodic
+def cos(x):
+    """Evaluates the cos of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.sin(x))
+    elif isinstance(x, interval):
+        if not (np.isfinite(x.start) and np.isfinite(x.end)):
+            return interval(-1, 1, is_valid=x.is_valid)
+        na, __ = divmod(x.start, np.pi / 2.0)
+        nb, __ = divmod(x.end, np.pi / 2.0)
+        start = min(np.cos(x.start), np.cos(x.end))
+        end = max(np.cos(x.start), np.cos(x.end))
+        if nb - na > 4:
+            #differ more than 2*pi
+            return interval(-1, 1, is_valid=x.is_valid)
+        elif na == nb:
+            #in the same quadarant
+            return interval(start, end, is_valid=x.is_valid)
+        else:
+            if (na) // 4 != (nb) // 4:
+                #cos has max
+                end = 1
+            if (na - 2) // 4 != (nb - 2) // 4:
+                #cos has min
+                start = -1
+            return interval(start, end, is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+def tan(x):
+    """Evaluates the tan of an interval"""
+    return sin(x) / cos(x)
+
+
+#Monotonic
+def sqrt(x):
+    """Evaluates the square root of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        if x > 0:
+            return interval(np.sqrt(x))
+        else:
+            return interval(-np.inf, np.inf, is_valid=False)
+    elif isinstance(x, interval):
+        #Outside the domain
+        if x.end < 0:
+            return interval(-np.inf, np.inf, is_valid=False)
+        #Partially outside the domain
+        elif x.start < 0:
+            return interval(-np.inf, np.inf, is_valid=None)
+        else:
+            return interval(np.sqrt(x.start), np.sqrt(x.end),
+                    is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+def imin(*args):
+    """Evaluates the minimum of a list of intervals"""
+    np = import_module('numpy')
+    if not all(isinstance(arg, (int, float, interval)) for arg in args):
+        return NotImplementedError
+    else:
+        new_args = [a for a in args if isinstance(a, (int, float))
+                    or a.is_valid]
+        if len(new_args) == 0:
+            if all(a.is_valid is False for a in args):
+                return interval(-np.inf, np.inf, is_valid=False)
+            else:
+                return interval(-np.inf, np.inf, is_valid=None)
+        start_array = [a if isinstance(a, (int, float)) else a.start
+                       for a in new_args]
+
+        end_array = [a if isinstance(a, (int, float)) else a.end
+                     for a in new_args]
+        return interval(min(start_array), min(end_array))
+
+
+def imax(*args):
+    """Evaluates the maximum of a list of intervals"""
+    np = import_module('numpy')
+    if not all(isinstance(arg, (int, float, interval)) for arg in args):
+        return NotImplementedError
+    else:
+        new_args = [a for a in args if isinstance(a, (int, float))
+                    or a.is_valid]
+        if len(new_args) == 0:
+            if all(a.is_valid is False for a in args):
+                return interval(-np.inf, np.inf, is_valid=False)
+            else:
+                return interval(-np.inf, np.inf, is_valid=None)
+        start_array = [a if isinstance(a, (int, float)) else a.start
+                       for a in new_args]
+
+        end_array = [a if isinstance(a, (int, float)) else a.end
+                     for a in new_args]
+
+        return interval(max(start_array), max(end_array))
+
+
+#Monotonic
+def sinh(x):
+    """Evaluates the hyperbolic sine of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.sinh(x), np.sinh(x))
+    elif isinstance(x, interval):
+        return interval(np.sinh(x.start), np.sinh(x.end), is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+def cosh(x):
+    """Evaluates the hyperbolic cos of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.cosh(x), np.cosh(x))
+    elif isinstance(x, interval):
+        #both signs
+        if x.start < 0 and x.end > 0:
+            end = max(np.cosh(x.start), np.cosh(x.end))
+            return interval(1, end, is_valid=x.is_valid)
+        else:
+            #Monotonic
+            start = np.cosh(x.start)
+            end = np.cosh(x.end)
+            return interval(start, end, is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+#Monotonic
+def tanh(x):
+    """Evaluates the hyperbolic tan of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.tanh(x), np.tanh(x))
+    elif isinstance(x, interval):
+        return interval(np.tanh(x.start), np.tanh(x.end), is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+def asin(x):
+    """Evaluates the inverse sine of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        #Outside the domain
+        if abs(x) > 1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            return interval(np.arcsin(x), np.arcsin(x))
+    elif isinstance(x, interval):
+        #Outside the domain
+        if x.is_valid is False or x.start > 1 or x.end < -1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        #Partially outside the domain
+        elif x.start < -1 or x.end > 1:
+            return interval(-np.inf, np.inf, is_valid=None)
+        else:
+            start = np.arcsin(x.start)
+            end = np.arcsin(x.end)
+            return interval(start, end, is_valid=x.is_valid)
+
+
+def acos(x):
+    """Evaluates the inverse cos of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        if abs(x) > 1:
+            #Outside the domain
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            return interval(np.arccos(x), np.arccos(x))
+    elif isinstance(x, interval):
+        #Outside the domain
+        if x.is_valid is False or x.start > 1 or x.end < -1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        #Partially outside the domain
+        elif x.start < -1 or x.end > 1:
+            return interval(-np.inf, np.inf, is_valid=None)
+        else:
+            start = np.arccos(x.start)
+            end = np.arccos(x.end)
+            return interval(start, end, is_valid=x.is_valid)
+
+
+def ceil(x):
+    """Evaluates the ceiling of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.ceil(x))
+    elif isinstance(x, interval):
+        if x.is_valid is False:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            start = np.ceil(x.start)
+            end = np.ceil(x.end)
+            #Continuous over the interval
+            if start == end:
+                return interval(start, end, is_valid=x.is_valid)
+            else:
+                #Not continuous over the interval
+                return interval(start, end, is_valid=None)
+    else:
+        return NotImplementedError
+
+
+def floor(x):
+    """Evaluates the floor of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.floor(x))
+    elif isinstance(x, interval):
+        if x.is_valid is False:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            start = np.floor(x.start)
+            end = np.floor(x.end)
+            #continuous over the argument
+            if start == end:
+                return interval(start, end, is_valid=x.is_valid)
+            else:
+                #not continuous over the interval
+                return interval(start, end, is_valid=None)
+    else:
+        return NotImplementedError
+
+
+def acosh(x):
+    """Evaluates the inverse hyperbolic cosine of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        #Outside the domain
+        if x < 1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            return interval(np.arccosh(x))
+    elif isinstance(x, interval):
+        #Outside the domain
+        if x.end < 1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        #Partly outside the domain
+        elif x.start < 1:
+            return interval(-np.inf, np.inf, is_valid=None)
+        else:
+            start = np.arccosh(x.start)
+            end = np.arccosh(x.end)
+            return interval(start, end, is_valid=x.is_valid)
+    else:
+        return NotImplementedError
+
+
+#Monotonic
+def asinh(x):
+    """Evaluates the inverse hyperbolic sine of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.arcsinh(x))
+    elif isinstance(x, interval):
+        start = np.arcsinh(x.start)
+        end = np.arcsinh(x.end)
+        return interval(start, end, is_valid=x.is_valid)
+    else:
+        return NotImplementedError
+
+
+def atanh(x):
+    """Evaluates the inverse hyperbolic tangent of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        #Outside the domain
+        if abs(x) >= 1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            return interval(np.arctanh(x))
+    elif isinstance(x, interval):
+        #outside the domain
+        if x.is_valid is False or x.start >= 1 or x.end <= -1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        #partly outside the domain
+        elif x.start <= -1 or x.end >= 1:
+            return interval(-np.inf, np.inf, is_valid=None)
+        else:
+            start = np.arctanh(x.start)
+            end = np.arctanh(x.end)
+            return interval(start, end, is_valid=x.is_valid)
+    else:
+        return NotImplementedError
+
+
+#Three valued logic for interval plotting.
+
+def And(*args):
+    """Defines the three valued ``And`` behaviour for a 2-tuple of
+     three valued logic values"""
+    def reduce_and(cmp_intervala, cmp_intervalb):
+        if cmp_intervala[0] is False or cmp_intervalb[0] is False:
+            first = False
+        elif cmp_intervala[0] is None or cmp_intervalb[0] is None:
+            first = None
+        else:
+            first = True
+        if cmp_intervala[1] is False or cmp_intervalb[1] is False:
+            second = False
+        elif cmp_intervala[1] is None or cmp_intervalb[1] is None:
+            second = None
+        else:
+            second = True
+        return (first, second)
+    return reduce(reduce_and, args)
+
+
+def Or(*args):
+    """Defines the three valued ``Or`` behaviour for a 2-tuple of
+     three valued logic values"""
+    def reduce_or(cmp_intervala, cmp_intervalb):
+        if cmp_intervala[0] is True or cmp_intervalb[0] is True:
+            first = True
+        elif cmp_intervala[0] is None or cmp_intervalb[0] is None:
+            first = None
+        else:
+            first = False
+
+        if cmp_intervala[1] is True or cmp_intervalb[1] is True:
+            second = True
+        elif cmp_intervala[1] is None or cmp_intervalb[1] is None:
+            second = None
+        else:
+            second = False
+        return (first, second)
+    return reduce(reduce_or, args)

venv/lib/python3.11/site-packages/sympy/plotting/intervalmath/tests/test_interval_functions.py

@@ -0,0 +1,415 @@
+from sympy.external import import_module
+from sympy.plotting.intervalmath import (
+    Abs, acos, acosh, And, asin, asinh, atan, atanh, ceil, cos, cosh,
+    exp, floor, imax, imin, interval, log, log10, Or, sin, sinh, sqrt,
+    tan, tanh,
+)
+
+np = import_module('numpy')
+if not np:
+    disabled = True
+
+
+#requires Numpy. Hence included in interval_functions
+
+
+def test_interval_pow():
+    a = 2**interval(1, 2) == interval(2, 4)
+    assert a == (True, True)
+    a = interval(1, 2)**interval(1, 2) == interval(1, 4)
+    assert a == (True, True)
+    a = interval(-1, 1)**interval(0.5, 2)
+    assert a.is_valid is None
+    a = interval(-2, -1) ** interval(1, 2)
+    assert a.is_valid is False
+    a = interval(-2, -1) ** (1.0 / 2)
+    assert a.is_valid is False
+    a = interval(-1, 1)**(1.0 / 2)
+    assert a.is_valid is None
+    a = interval(-1, 1)**(1.0 / 3) == interval(-1, 1)
+    assert a == (True, True)
+    a = interval(-1, 1)**2 == interval(0, 1)
+    assert a == (True, True)
+    a = interval(-1, 1) ** (1.0 / 29) == interval(-1, 1)
+    assert a == (True, True)
+    a = -2**interval(1, 1) == interval(-2, -2)
+    assert a == (True, True)
+
+    a = interval(1, 2, is_valid=False)**2
+    assert a.is_valid is False
+
+    a = (-3)**interval(1, 2)
+    assert a.is_valid is False
+    a = (-4)**interval(0.5, 0.5)
+    assert a.is_valid is False
+    assert ((-3)**interval(1, 1) == interval(-3, -3)) == (True, True)
+
+    a = interval(8, 64)**(2.0 / 3)
+    assert abs(a.start - 4) < 1e-10  # eps
+    assert abs(a.end - 16) < 1e-10
+    a = interval(-8, 64)**(2.0 / 3)
+    assert abs(a.start - 4) < 1e-10  # eps
+    assert abs(a.end - 16) < 1e-10
+
+
+def test_exp():
+    a = exp(interval(-np.inf, 0))
+    assert a.start == np.exp(-np.inf)
+    assert a.end == np.exp(0)
+    a = exp(interval(1, 2))
+    assert a.start == np.exp(1)
+    assert a.end == np.exp(2)
+    a = exp(1)
+    assert a.start == np.exp(1)
+    assert a.end == np.exp(1)
+
+
+def test_log():
+    a = log(interval(1, 2))
+    assert a.start == 0
+    assert a.end == np.log(2)
+    a = log(interval(-1, 1))
+    assert a.is_valid is None
+    a = log(interval(-3, -1))
+    assert a.is_valid is False
+    a = log(-3)
+    assert a.is_valid is False
+    a = log(2)
+    assert a.start == np.log(2)
+    assert a.end == np.log(2)
+
+
+def test_log10():
+    a = log10(interval(1, 2))
+    assert a.start == 0
+    assert a.end == np.log10(2)
+    a = log10(interval(-1, 1))
+    assert a.is_valid is None
+    a = log10(interval(-3, -1))
+    assert a.is_valid is False
+    a = log10(-3)
+    assert a.is_valid is False
+    a = log10(2)
+    assert a.start == np.log10(2)
+    assert a.end == np.log10(2)
+
+
+def test_atan():
+    a = atan(interval(0, 1))
+    assert a.start == np.arctan(0)
+    assert a.end == np.arctan(1)
+    a = atan(1)
+    assert a.start == np.arctan(1)
+    assert a.end == np.arctan(1)
+
+
+def test_sin():
+    a = sin(interval(0, np.pi / 4))
+    assert a.start == np.sin(0)
+    assert a.end == np.sin(np.pi / 4)
+
+    a = sin(interval(-np.pi / 4, np.pi / 4))
+    assert a.start == np.sin(-np.pi / 4)
+    assert a.end == np.sin(np.pi / 4)
+
+    a = sin(interval(np.pi / 4, 3 * np.pi / 4))
+    assert a.start == np.sin(np.pi / 4)
+    assert a.end == 1
+
+    a = sin(interval(7 * np.pi / 6, 7 * np.pi / 4))
+    assert a.start == -1
+    assert a.end == np.sin(7 * np.pi / 6)
+
+    a = sin(interval(0, 3 * np.pi))
+    assert a.start == -1
+    assert a.end == 1
+
+    a = sin(interval(np.pi / 3, 7 * np.pi / 4))
+    assert a.start == -1
+    assert a.end == 1
+
+    a = sin(np.pi / 4)
+    assert a.start == np.sin(np.pi / 4)
+    assert a.end == np.sin(np.pi / 4)
+
+    a = sin(interval(1, 2, is_valid=False))
+    assert a.is_valid is False
+
+
+def test_cos():
+    a = cos(interval(0, np.pi / 4))
+    assert a.start == np.cos(np.pi / 4)
+    assert a.end == 1
+
+    a = cos(interval(-np.pi / 4, np.pi / 4))
+    assert a.start == np.cos(-np.pi / 4)
+    assert a.end == 1
+
+    a = cos(interval(np.pi / 4, 3 * np.pi / 4))
+    assert a.start == np.cos(3 * np.pi / 4)
+    assert a.end == np.cos(np.pi / 4)
+
+    a = cos(interval(3 * np.pi / 4, 5 * np.pi / 4))
+    assert a.start == -1
+    assert a.end == np.cos(3 * np.pi / 4)
+
+    a = cos(interval(0, 3 * np.pi))
+    assert a.start == -1
+    assert a.end == 1
+
+    a = cos(interval(- np.pi / 3, 5 * np.pi / 4))
+    assert a.start == -1
+    assert a.end == 1
+
+    a = cos(interval(1, 2, is_valid=False))
+    assert a.is_valid is False
+
+
+def test_tan():
+    a = tan(interval(0, np.pi / 4))
+    assert a.start == 0
+    # must match lib_interval definition of tan:
+    assert a.end == np.sin(np.pi / 4)/np.cos(np.pi / 4)
+
+    a = tan(interval(np.pi / 4, 3 * np.pi / 4))
+    #discontinuity
+    assert a.is_valid is None
+
+
+def test_sqrt():
+    a = sqrt(interval(1, 4))
+    assert a.start == 1
+    assert a.end == 2
+
+    a = sqrt(interval(0.01, 1))
+    assert a.start == np.sqrt(0.01)
+    assert a.end == 1
+
+    a = sqrt(interval(-1, 1))
+    assert a.is_valid is None
+
+    a = sqrt(interval(-3, -1))
+    assert a.is_valid is False
+
+    a = sqrt(4)
+    assert (a == interval(2, 2)) == (True, True)
+
+    a = sqrt(-3)
+    assert a.is_valid is False
+
+
+def test_imin():
+    a = imin(interval(1, 3), interval(2, 5), interval(-1, 3))
+    assert a.start == -1
+    assert a.end == 3
+
+    a = imin(-2, interval(1, 4))
+    assert a.start == -2
+    assert a.end == -2
+
+    a = imin(5, interval(3, 4), interval(-2, 2, is_valid=False))
+    assert a.start == 3
+    assert a.end == 4
+
+
+def test_imax():
+    a = imax(interval(-2, 2), interval(2, 7), interval(-3, 9))
+    assert a.start == 2
+    assert a.end == 9
+
+    a = imax(8, interval(1, 4))
+    assert a.start == 8
+    assert a.end == 8
+
+    a = imax(interval(1, 2), interval(3, 4), interval(-2, 2, is_valid=False))
+    assert a.start == 3
+    assert a.end == 4
+
+
+def test_sinh():
+    a = sinh(interval(-1, 1))
+    assert a.start == np.sinh(-1)
+    assert a.end == np.sinh(1)
+
+    a = sinh(1)
+    assert a.start == np.sinh(1)
+    assert a.end == np.sinh(1)
+
+
+def test_cosh():
+    a = cosh(interval(1, 2))
+    assert a.start == np.cosh(1)
+    assert a.end == np.cosh(2)
+    a = cosh(interval(-2, -1))
+    assert a.start == np.cosh(-1)
+    assert a.end == np.cosh(-2)
+
+    a = cosh(interval(-2, 1))
+    assert a.start == 1
+    assert a.end == np.cosh(-2)
+
+    a = cosh(1)
+    assert a.start == np.cosh(1)
+    assert a.end == np.cosh(1)
+
+
+def test_tanh():
+    a = tanh(interval(-3, 3))
+    assert a.start == np.tanh(-3)
+    assert a.end == np.tanh(3)
+
+    a = tanh(3)
+    assert a.start == np.tanh(3)
+    assert a.end == np.tanh(3)
+
+
+def test_asin():
+    a = asin(interval(-0.5, 0.5))
+    assert a.start == np.arcsin(-0.5)
+    assert a.end == np.arcsin(0.5)
+
+    a = asin(interval(-1.5, 1.5))
+    assert a.is_valid is None
+    a = asin(interval(-2, -1.5))
+    assert a.is_valid is False
+
+    a = asin(interval(0, 2))
+    assert a.is_valid is None
+
+    a = asin(interval(2, 5))
+    assert a.is_valid is False
+
+    a = asin(0.5)
+    assert a.start == np.arcsin(0.5)
+    assert a.end == np.arcsin(0.5)
+
+    a = asin(1.5)
+    assert a.is_valid is False
+
+
+def test_acos():
+    a = acos(interval(-0.5, 0.5))
+    assert a.start == np.arccos(0.5)
+    assert a.end == np.arccos(-0.5)
+
+    a = acos(interval(-1.5, 1.5))
+    assert a.is_valid is None
+    a = acos(interval(-2, -1.5))
+    assert a.is_valid is False
+
+    a = acos(interval(0, 2))
+    assert a.is_valid is None
+
+    a = acos(interval(2, 5))
+    assert a.is_valid is False
+
+    a = acos(0.5)
+    assert a.start == np.arccos(0.5)
+    assert a.end == np.arccos(0.5)
+
+    a = acos(1.5)
+    assert a.is_valid is False
+
+
+def test_ceil():
+    a = ceil(interval(0.2, 0.5))
+    assert a.start == 1
+    assert a.end == 1
+
+    a = ceil(interval(0.5, 1.5))
+    assert a.start == 1
+    assert a.end == 2
+    assert a.is_valid is None
+
+    a = ceil(interval(-5, 5))
+    assert a.is_valid is None
+
+    a = ceil(5.4)
+    assert a.start == 6
+    assert a.end == 6
+
+
+def test_floor():
+    a = floor(interval(0.2, 0.5))
+    assert a.start == 0
+    assert a.end == 0
+
+    a = floor(interval(0.5, 1.5))
+    assert a.start == 0
+    assert a.end == 1
+    assert a.is_valid is None
+
+    a = floor(interval(-5, 5))
+    assert a.is_valid is None
+
+    a = floor(5.4)
+    assert a.start == 5
+    assert a.end == 5
+
+
+def test_asinh():
+    a = asinh(interval(1, 2))
+    assert a.start == np.arcsinh(1)
+    assert a.end == np.arcsinh(2)
+
+    a = asinh(0.5)
+    assert a.start == np.arcsinh(0.5)
+    assert a.end == np.arcsinh(0.5)
+
+
+def test_acosh():
+    a = acosh(interval(3, 5))
+    assert a.start == np.arccosh(3)
+    assert a.end == np.arccosh(5)
+
+    a = acosh(interval(0, 3))
+    assert a.is_valid is None
+    a = acosh(interval(-3, 0.5))
+    assert a.is_valid is False
+
+    a = acosh(0.5)
+    assert a.is_valid is False
+
+    a = acosh(2)
+    assert a.start == np.arccosh(2)
+    assert a.end == np.arccosh(2)
+
+
+def test_atanh():
+    a = atanh(interval(-0.5, 0.5))
+    assert a.start == np.arctanh(-0.5)
+    assert a.end == np.arctanh(0.5)
+
+    a = atanh(interval(0, 3))
+    assert a.is_valid is None
+
+    a = atanh(interval(-3, -2))
+    assert a.is_valid is False
+
+    a = atanh(0.5)
+    assert a.start == np.arctanh(0.5)
+    assert a.end == np.arctanh(0.5)
+
+    a = atanh(1.5)
+    assert a.is_valid is False
+
+
+def test_Abs():
+    assert (Abs(interval(-0.5, 0.5)) == interval(0, 0.5)) == (True, True)
+    assert (Abs(interval(-3, -2)) == interval(2, 3)) == (True, True)
+    assert (Abs(-3) == interval(3, 3)) == (True, True)
+
+
+def test_And():
+    args = [(True, True), (True, False), (True, None)]
+    assert And(*args) == (True, False)
+
+    args = [(False, True), (None, None), (True, True)]
+    assert And(*args) == (False, None)
+
+
+def test_Or():
+    args = [(True, True), (True, False), (False, None)]
+    assert Or(*args) == (True, True)
+    args = [(None, None), (False, None), (False, False)]
+    assert Or(*args) == (None, None)

venv/lib/python3.11/site-packages/sympy/plotting/intervalmath/tests/test_interval_membership.py

@@ -0,0 +1,150 @@
+from sympy.core.symbol import Symbol
+from sympy.plotting.intervalmath import interval
+from sympy.plotting.intervalmath.interval_membership import intervalMembership
+from sympy.plotting.experimental_lambdify import experimental_lambdify
+from sympy.testing.pytest import raises
+
+
+def test_creation():
+    assert intervalMembership(True, True)
+    raises(TypeError, lambda: intervalMembership(True))
+    raises(TypeError, lambda: intervalMembership(True, True, True))
+
+
+def test_getitem():
+    a = intervalMembership(True, False)
+    assert a[0] is True
+    assert a[1] is False
+    raises(IndexError, lambda: a[2])
+
+
+def test_str():
+    a = intervalMembership(True, False)
+    assert str(a) == 'intervalMembership(True, False)'
+    assert repr(a) == 'intervalMembership(True, False)'
+
+
+def test_equivalence():
+    a = intervalMembership(True, True)
+    b = intervalMembership(True, False)
+    assert (a == b) is False
+    assert (a != b) is True
+
+    a = intervalMembership(True, False)
+    b = intervalMembership(True, False)
+    assert (a == b) is True
+    assert (a != b) is False
+
+
+def test_not():
+    x = Symbol('x')
+
+    r1 = x > -1
+    r2 = x <= -1
+
+    i = interval
+
+    f1 = experimental_lambdify((x,), r1)
+    f2 = experimental_lambdify((x,), r2)
+
+    tt = i(-0.1, 0.1, is_valid=True)
+    tn = i(-0.1, 0.1, is_valid=None)
+    tf = i(-0.1, 0.1, is_valid=False)
+
+    assert f1(tt) == ~f2(tt)
+    assert f1(tn) == ~f2(tn)
+    assert f1(tf) == ~f2(tf)
+
+    nt = i(0.9, 1.1, is_valid=True)
+    nn = i(0.9, 1.1, is_valid=None)
+    nf = i(0.9, 1.1, is_valid=False)
+
+    assert f1(nt) == ~f2(nt)
+    assert f1(nn) == ~f2(nn)
+    assert f1(nf) == ~f2(nf)
+
+    ft = i(1.9, 2.1, is_valid=True)
+    fn = i(1.9, 2.1, is_valid=None)
+    ff = i(1.9, 2.1, is_valid=False)
+
+    assert f1(ft) == ~f2(ft)
+    assert f1(fn) == ~f2(fn)
+    assert f1(ff) == ~f2(ff)
+
+
+def test_boolean():
+    # There can be 9*9 test cases in full mapping of the cartesian product.
+    # But we only consider 3*3 cases for simplicity.
+    s = [
+        intervalMembership(False, False),
+        intervalMembership(None, None),
+        intervalMembership(True, True)
+    ]
+
+    # Reduced tests for 'And'
+    a1 = [
+        intervalMembership(False, False),
+        intervalMembership(False, False),
+        intervalMembership(False, False),
+        intervalMembership(False, False),
+        intervalMembership(None, None),
+        intervalMembership(None, None),
+        intervalMembership(False, False),
+        intervalMembership(None, None),
+        intervalMembership(True, True)
+    ]
+    a1_iter = iter(a1)
+    for i in range(len(s)):
+        for j in range(len(s)):
+            assert s[i] & s[j] == next(a1_iter)
+
+    # Reduced tests for 'Or'
+    a1 = [
+        intervalMembership(False, False),
+        intervalMembership(None, False),
+        intervalMembership(True, False),
+        intervalMembership(None, False),
+        intervalMembership(None, None),
+        intervalMembership(True, None),
+        intervalMembership(True, False),
+        intervalMembership(True, None),
+        intervalMembership(True, True)
+    ]
+    a1_iter = iter(a1)
+    for i in range(len(s)):
+        for j in range(len(s)):
+            assert s[i] | s[j] == next(a1_iter)
+
+    # Reduced tests for 'Xor'
+    a1 = [
+        intervalMembership(False, False),
+        intervalMembership(None, False),
+        intervalMembership(True, False),
+        intervalMembership(None, False),
+        intervalMembership(None, None),
+        intervalMembership(None, None),
+        intervalMembership(True, False),
+        intervalMembership(None, None),
+        intervalMembership(False, True)
+    ]
+    a1_iter = iter(a1)
+    for i in range(len(s)):
+        for j in range(len(s)):
+            assert s[i] ^ s[j] == next(a1_iter)
+
+    # Reduced tests for 'Not'
+    a1 = [
+        intervalMembership(True, False),
+        intervalMembership(None, None),
+        intervalMembership(False, True)
+    ]
+    a1_iter = iter(a1)
+    for i in range(len(s)):
+        assert ~s[i] == next(a1_iter)
+
+
+def test_boolean_errors():
+    a = intervalMembership(True, True)
+    raises(ValueError, lambda: a & 1)
+    raises(ValueError, lambda: a | 1)
+    raises(ValueError, lambda: a ^ 1)