release: ready to release v1.6.0

* fix: reduce warning from numpy

* fix: fix ControlsExample

.github/ISSUE_TEMPLATE.md

@@ -1,14 +0,0 @@
-### If this is a support request:
-
-**Please attempt to solve the problem on your own before opening an issue.**
-Between old issues, StackOverflow, and Google, you should be able to find
-solutions to most of the common problems.
-
-Include at least:
-1. Steps to reproduce the issue (e.g. the command you ran)
-2. The unexpected behavior that occurred (e.g. error messages or screenshots)
-3. The environment (e.g. operating system and version of manim)
-
-
-### If this is a feature request:
-Include the motivation for making this change.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,20 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+### Describe the bug
+<!-- A clear and concise description of what the bug is. -->
+
+**Code**:
+<!-- The code you run which reflect the bug. -->
+
+**Wrong display or Error traceback**:
+<!-- the wrong display result of the code you run, or the error Traceback -->
+
+### Additional context
+<!-- Add any other context about the problem here. -->

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: true
+contact_links:
+  - name: Ask A Question
+    url: https://github.com/3b1b/manim/discussions/categories/q-a
+    about: Please ask questions you encountered here.

.github/ISSUE_TEMPLATE/error-when-using.md

@@ -0,0 +1,23 @@
+---
+name: Error when using
+about: The error you encountered while using manim
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+### Describe the error
+<!-- A clear and concise description of what you want to make. -->
+
+### Code and Error
+**Code**:
+<!-- The code you run -->
+
+**Error**:
+<!-- The error traceback you get when run your code -->
+
+### Environment
+**OS System**: 
+**manim version**: master <!-- make sure you are using the latest version of master branch -->
+**python version**:

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,9 +1,18 @@
-Thanks for contributing to manim!
+<!-- Thanks for contributing to manim!
+    Please ensure that your pull request works with the latest version of manim.
+-->
 
-**Please ensure that your pull request works with the latest version of manim.**
-You should also include:
+## Motivation
+<!-- Outline your motivation: In what way do your changes improve the library? -->
 
-1. The motivation for making this change (or link the relevant issues)
-2. How you tested the new behavior (e.g. a minimal working example, before/after
-screenshots, gifs, commands, etc.) This is rather informal at the moment, but
-the goal is to show us how you know the pull request works as intended.
+## Proposed changes
+<!-- What you changed in those files -->
+- 
+- 
+- 
+
+## Test
+<!-- How do you test your changes -->
+**Code**:
+
+**Result**:

.github/workflows/docs.yml

@@ -0,0 +1,40 @@
+name: docs
+
+on: 
+  push:
+    paths:
+      - 'docs/**'
+  pull_request:
+    paths:
+      - 'docs/**'
+
+jobs:
+  docs:
+    runs-on: ubuntu-latest
+    name: build up document and deploy
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@master
+    
+    - name: Install sphinx and manim env
+      run: |
+        pip3 install --upgrade pip
+        sudo apt install python3-setuptools libpango1.0-dev
+        pip3 install -r docs/requirements.txt
+        pip3 install -r requirements.txt
+    
+    - name: Build document with Sphinx
+      run: |
+        cd docs
+        export PATH="$PATH:/home/runner/.local/bin"
+        export SPHINXBUILD="python3 -m sphinx"
+        make html
+        
+    - name: Deploy to GitHub pages
+      if: ${{ github.event_name == 'push' }}
+      uses: JamesIves/github-pages-deploy-action@3.7.1
+      with:
+        ACCESS_TOKEN: ${{ secrets.DOC_DEPLOY_TOKEN }}
+        BRANCH: gh-pages
+        FOLDER: docs/build/html

.github/workflows/publish.yml

@@ -0,0 +1,37 @@
+name: Upload Python Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        python: ["py37", "py38", "py39", "py310"]
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.8'
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install setuptools wheel twine build
+
+    - name: Build wheels
+      run: python setup.py bdist_wheel --python-tag ${{ matrix.python }}
+
+    - name: Upload wheels
+      env:
+        TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
+        TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
+      run: |
+        twine upload dist/*

.gitignore

@@ -1,28 +1,152 @@
-*.pyc
-*.bak
-.DS_Store
-homeless.py
-playground.py
-cairo_test.py
-mayavi_test.py
-random_scenes/
-files/
-assets/
-ben_playground.py
-ben_cairo_test.py
-.floo
-.flooignore
-.vscode
-.vs
-*.xml
-*.iml
-media
-manim.sublime-project
-manim.sublime-workspace
-.eggs/
-build/
-dist/
-manim.egg-info/
+# Created by https://www.toptal.com/developers/gitignore/api/python
+# Edit at https://www.toptal.com/developers/gitignore?templates=python
 
-primes.py
-/media_dir.txt
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+manimlib.egg-info/
+
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+pytestdebug.log
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+doc/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+pythonenv*
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# profiling data
+.prof
+
+# End of https://www.toptal.com/developers/gitignore/api/python
+# Custom exclusions:
+.DS_Store
+
+# For manim
+/videos
+/custom_config.yml

.travis.yml

@@ -1,30 +0,0 @@
-language: python
-dist: bionic
-python: "3.7"
-cache: pip
-
-addons:
-  apt:
-    packages:
-      - python3-sphinx
-install:
-  - pip install --upgrade pip
-  - pip install -r requirements.txt
-  - pip install flake8
-before_script:
-  # stop the build if there are Python syntax errors or undefined names
-  - flake8 manimlib/ --count --select=E9,F63,F72,F82 --show-source --statistics
-  # exit-zero treats all errors as warnings.  The GitHub editor is 127 chars wide
-  - flake8 manimlib/ --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
-script:
-  - python setup.py test
-  - python setup.py bdist_wheel
-after_success:
-  - test $TRAVIS_BRANCH = "master" && test $TRAVIS_PULL_REQUEST = "false" && travis/build_docs.sh
-deploy:
-  provider: pypi
-  user: eulertour
-  on:
-    tags: true
-  password:
-    secure: j5M2hiJo9kDWJhl0/iSuIQmfd2G2O1Qoc455AkUPMCheAcALnX9xJgFsYBmqfgOXTCtUCQf52XGdOIG4o4s5TY340NZ9eLKI9cWae+sTeSrDCkdwChUilm3D0jQf1FWPUf9ywScwGi20m0sRtzxEJyTuX+JMFd7PIa8bFoDXWPtEjoFOOJrfBusMsANzrI+j+vIMdJ48lc1J8UsQdZapwusTrYU9s12JLhKBPLavmaDKf0HDAJdEhFQ9SaINdkiW/QY8qbfJ/MVu5jHai168zXjD/IaswxoKqCO1G+fWlOq3KwVhG7gI7rwhnnuF+wcA7yLAaMdo0CjO2V7z15S6cG721V2Il2IIh1jq0F8irSH1ZOLOkv/fFk9hkSUQyEU0i8k4m1wE9L47a6GP/66+b+gI91PGfxBOqq4gE/1BdZJqceh0qc13KpcehtYrQwR05bSw0Ye5OoTkqAnCeON0B0Ur4ejfHd3TzkjgB06fw76cZtjAK8f/YjB3KyNCvysOixgzE4tRxlY92yX/tAKZ3iX3yD0MjsinSfwo52N5sIEaCS/FmPRMhJOQBa6ftkfbcUNQBTG9G3b134XXF/LbC4vBloCaTm5VSXagta+oY3SFKQxPAZXx7X+wcFGjqxDjZXG1e66QnA2JJH4aBDsRfSXmUtD8MblwFYdcCJWz+Ck=

Dockerfile

@@ -1,19 +0,0 @@
-FROM python:3.7
-RUN apt-get update \
-    && apt-get install -qqy --no-install-recommends \
-        apt-utils \
-        ffmpeg \
-        sox \
-        libcairo2-dev \
-        texlive \
-        texlive-fonts-extra \
-        texlive-latex-extra \
-        texlive-latex-recommended \
-        texlive-science \
-        tipa \
-    && rm -rf /var/lib/apt/lists/*
-COPY . /manim
-RUN cd /manim \
-    && python setup.py sdist \
-    && python -m pip install dist/manimlib*
-ENTRYPOINT ["/bin/bash"]

LICENSE.md

@@ -1,10 +1,6 @@
-All files of this project under the directory "from_3b1b" are copyright 3Blue1Brown LLC and used by permission for this project only.
-
-Any other file of this project is available under the MIT license as follow:
-
 MIT License
 
-Copyright (c) 2018 3Blue1Brown LLC
+Copyright (c) 2020 3Blue1Brown LLC
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

MANIFEST.in

@@ -0,0 +1,2 @@
+graft manimlib
+recursive-exclude manimlib *.pyc *.DS_Store

README.md

@@ -1,138 +1,117 @@
-![logo](logo/cropped.png)
+<p align="center">
+    <a href="https://github.com/3b1b/manim">
+        <img src="https://raw.githubusercontent.com/3b1b/manim/master/logo/cropped.png">
+    </a>
+</p>
 
-[![Build Status](https://travis-ci.org/3b1b/manim.svg?branch=master)](https://travis-ci.org/3b1b/manim)
-[![Documentation](https://img.shields.io/badge/docs-EulerTour-blue.svg)](https://www.eulertour.com/docs)
+[![pypi version](https://img.shields.io/pypi/v/manimgl?logo=pypi)](https://pypi.org/project/manimgl/)
 [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg?style=flat)](http://choosealicense.com/licenses/mit/)
-[![Manim Subreddit](https://img.shields.io/reddit/subreddit-subscribers/manim.svg?color=ff4301&label=reddit)](https://www.reddit.com/r/manim/)
-[![Manim Discord](https://img.shields.io/discord/581738731934056449.svg?label=discord)](https://discord.gg/mMRrZQW)
+[![Manim Subreddit](https://img.shields.io/reddit/subreddit-subscribers/manim.svg?color=ff4301&label=reddit&logo=reddit)](https://www.reddit.com/r/manim/)
+[![Manim Discord](https://img.shields.io/discord/581738731934056449.svg?label=discord&logo=discord)](https://discord.com/invite/bYCyhM9Kz2)
+[![docs](https://github.com/3b1b/manim/workflows/docs/badge.svg)](https://3b1b.github.io/manim/)
 
-Manim is an animation engine for explanatory math videos. It's used to create precise animations programmatically, as seen in the videos at [3Blue1Brown](https://www.3blue1brown.com/).
+Manim is an engine for precise programmatic animations, designed for creating explanatory math videos.
 
-This repository contains the version of manim used by 3Blue1Brown. There is also a community maintained version at https://github.com/ManimCommunity/manim/.
-To get help or to join the development effort, please join the [discord](https://discord.gg/mMRrZQW).
+Note, there are two versions of manim.  This repository began as a personal project by the author of [3Blue1Brown](https://www.3blue1brown.com/) for the purpose of animating those videos, with video-specific code available [here](https://github.com/3b1b/videos).  In 2020 a group of developers forked it into what is now the [community edition](https://github.com/ManimCommunity/manim/), with a goal of being more stable, better tested, quicker to respond to community contributions, and all around friendlier to get started with. See [this page](https://docs.manim.community/en/stable/installation/versions.html?highlight=OpenGL#which-version-to-use) for more details.
 
 ## Installation
-Manim runs on Python 3.6 or higher version. You can install it from PyPI via pip:
+> **WARNING:** These instructions are for ManimGL _only_. Trying to use these instructions to install [ManimCommunity/manim](https://github.com/ManimCommunity/manim) or instructions there to install this version will cause problems. You should first decide which version you wish to install, then only follow the instructions for your desired version.
+> 
+> **Note**: To install manim directly through pip, please pay attention to the name of the installed package. This repository is ManimGL of 3b1b. The package name is `manimgl` instead of `manim` or `manimlib`. Please use `pip install manimgl` to install the version in this repository.
+
+Manim runs on Python 3.7 or higher.
+
+System requirements are [FFmpeg](https://ffmpeg.org/), [OpenGL](https://www.opengl.org/) and [LaTeX](https://www.latex-project.org) (optional, if you want to use LaTeX).
+For Linux, [Pango](https://pango.gnome.org) along with its development headers are required. See instruction [here](https://github.com/ManimCommunity/ManimPango#building).
+
+
+### Directly
 
 ```sh
-pip3 install manimlib
-```
+# Install manimgl
+pip install manimgl
 
-System requirements are [cairo](https://www.cairographics.org), [ffmpeg](https://www.ffmpeg.org), [sox](http://sox.sourceforge.net) (optional, if you want to play the prompt tone after running), [latex](https://www.latex-project.org) (optional, if you want to use LaTeX).
-
-You can now use it via the `manim` command. For example:
-
-```sh
-manim my_project.py MyScene
+# Try it out
+manimgl
 ```
 
 For more options, take a look at the [Using manim](#using-manim) sections further below.
 
-### Directly
-
 If you want to hack on manimlib itself, clone this repository and in that directory execute:
 
 ```sh
-# Install python requirements
-python3 -m pip install -r requirements.txt
+# Install manimgl
+pip install -e .
 
 # Try it out
-python3 ./manim.py example_scenes.py SquareToCircle -pl
+manimgl example_scenes.py OpeningManimExample
+# or
+manim-render example_scenes.py OpeningManimExample
 ```
 
 ### Directly (Windows)
+
 1. [Install FFmpeg](https://www.wikihow.com/Install-FFmpeg-on-Windows).
-2. [Install Cairo](https://www.lfd.uci.edu/~gohlke/pythonlibs/#pycairo). For most users, ``pycairo‑1.18.0‑cp37‑cp37m‑win32.whl`` will do fine (you can download it or other versions from [here](https://www.lfd.uci.edu/~gohlke/pythonlibs/#pycairo)).
-    ```sh
-    pip3 install C:\path\to\wheel\pycairo‑1.18.0‑cp37‑cp37m‑win32.whl
-    ```
-3. Install a LaTeX distribution. [MiKTeX](https://miktex.org/download) is recommended.
-
-4. [Install SoX](https://sourceforge.net/projects/sox/files/sox/).
-
-5. Install the remaining Python packages.
+2. Install a LaTeX distribution. [MiKTeX](https://miktex.org/download) is recommended.
+3. Install the remaining Python packages.
     ```sh
     git clone https://github.com/3b1b/manim.git
     cd manim
-    pip3 install -r requirements.txt
-    python3 manim.py example_scenes.py SquareToCircle -pl
+    pip install -e .
+    manimgl example_scenes.py OpeningManimExample
     ```
 
+### Mac OSX
+
+1. Install FFmpeg, LaTeX in terminal using homebrew.
+    ```sh
+    brew install ffmpeg mactex
+    ```
+   
+2. Install latest version of manim using these command.
+    ```sh
+    git clone https://github.com/3b1b/manim.git
+    cd manim
+    pip install -e .
+    manimgl example_scenes.py OpeningManimExample
+    ```
 
 ## Anaconda Install
 
-* Install sox and latex as above. 
-* Create a conda environment using `conda env create -f environment.yml`
-* **WINDOWS ONLY** Install `pyreadline` via `pip install pyreadline`. 
+1. Install LaTeX as above.
+2. Create a conda environment using `conda create -n manim python=3.8`.
+3. Activate the environment using `conda activate manim`.
+4. Install manimgl using `pip install -e .`.
 
 
-### Using `virtualenv` and `virtualenvwrapper`
-After installing `virtualenv` and `virtualenvwrapper`
-```sh
-git clone https://github.com/3b1b/manim.git
-mkvirtualenv -a manim -r requirements.txt manim
-python3 -m manim example_scenes.py SquareToCircle -pl
-```
-
-### Using Docker
-Since it's a bit tricky to get all the dependencies set up just right, there is a Dockerfile and Compose file provided in this repo as well as [a premade image on Docker Hub](https://hub.docker.com/r/eulertour/manim/tags/). The Dockerfile contains instructions on how to build a manim image, while the Compose file contains instructions on how to run the image.
-
-The prebuilt container image has manim repository included.
-`INPUT_PATH` is where the container looks for scene files. You must set the `INPUT_PATH`
-environment variable to the absolute path containing your scene file and the
-`OUTPUT_PATH` environment variable to the directory where you want media to be written.
-
-1. [Install Docker](https://docs.docker.com)
-2. [Install Docker Compose](https://docs.docker.com/compose/install/)
-3. Render an animation:
-```sh
-INPUT_PATH=/path/to/dir/containing/source/code \
-OUTPUT_PATH=/path/to/output/ \
-docker-compose run manim example_scenes.py SquareToCircle -l
-```
-The command needs to be run as root if your username is not in the docker group.
-
-You can replace `example.scenes.py` with any relative path from your `INPUT_PATH`.
-
-![docker diagram](./manim_docker_diagram.png)
-
-After running the output will say files ready at `/tmp/output/`, which refers to path inside the container. Your `OUTPUT_PATH` is bind mounted to this `/tmp/output` so any changes made by the container to `/tmp/output` will be mirrored on your `OUTPUT_PATH`. `/media/` will be created in `OUTPUT_PATH`.
-
-`-p` won't work as manim would look for video player in the container system, which it does not have.
-
-The first time you execute the above command, Docker will pull the image from Docker Hub and cache it. Any subsequent runs until the image is evicted will use the cached image.
-Note that the image doesn't have any development tools installed and can't preview animations. Its purpose is building and testing only.
-
 ## Using manim
 Try running the following:
 ```sh
-python3 -m manim example_scenes.py SquareToCircle -pl
+manimgl example_scenes.py OpeningManimExample
 ```
-The `-p` flag in the command above is for previewing, meaning the video file will automatically open when it is done rendering. The `-l` flag is for a faster rendering at a lower quality.
+This should pop up a window playing a simple scene.
 
-Some other useful flags include:
+Some useful flags include:
+* `-w` to write the scene to a file
+* `-o` to write the scene to a file and open the result
 * `-s` to skip to the end and just show the final frame.
+    * `-so` will save the final frame to an image and show it
 * `-n <number>` to skip ahead to the `n`'th animation of a scene.
-* `-f` to show the file in finder (for OSX).
+* `-f` to make the playback window fullscreen
 
-Set `MEDIA_DIR` environment variable to specify where the image and animation files will be written.
+Take a look at custom_config.yml for further configuration.  To add your customization, you can either edit this file, or add another file by the same name "custom_config.yml" to whatever directory you are running manim from.  For example [this is the one](https://github.com/3b1b/videos/blob/master/custom_config.yml) for 3blue1brown videos.  There you can specify where videos should be output to, where manim should look for image files and sounds you want to read in, and other defaults regarding style and video quality.
 
-Look through the `old_projects` folder to see the code for previous 3b1b videos. Note, however, that developments are often made to the library without considering backwards compatibility with those old projects. To run an old project with a guarantee that it will work, you will have to go back to the commit which completed that project.
-
-While developing a scene, the `-sp` flags are helpful to just see what things look like at the end without having to generate the full animation. It can also be helpful to use the `-n` flag to skip over some number of animations.
+Look through the [example scenes](https://3b1b.github.io/manim/getting_started/example_scenes.html) to get a sense of how it is used, and feel free to look through the code behind [3blue1brown videos](https://github.com/3b1b/videos) for a much larger set of example. Note, however, that developments are often made to the library without considering backwards compatibility with those old videos. To run an old project with a guarantee that it will work, you will have to go back to the commit which completed that project.
 
 ### Documentation
-Documentation is in progress at [eulertour.com/docs](https://www.eulertour.com/docs/). And there is also an all-in-one documentation and tutorials maintained by **@manim-kindergarten**: [manim.ml](https://manim.ml/) (in Chinese).
-
-### Walkthrough
-Todd Zimmerman put together a [tutorial](https://talkingphysics.wordpress.com/2019/01/08/getting-started-animating-with-manim-and-python-3-7/) on getting started with manim, which has been updated to run on Python 3.7.
+Documentation is in progress at [3b1b.github.io/manim](https://3b1b.github.io/manim/). And there is also a Chinese version maintained by [**@manim-kindergarten**](https://manim.org.cn): [docs.manim.org.cn](https://docs.manim.org.cn/) (in Chinese).
 
 [manim-kindergarten](https://github.com/manim-kindergarten/) wrote and collected some useful extra classes and some codes of videos in [manim_sandbox repo](https://github.com/manim-kindergarten/manim_sandbox).
 
+
 ## Contributing
-Only accepts pull requests that fixes bugs / fixes typos / improves existing content (for more information, see [#1243](https://github.com/3b1b/manim/issues/1243)). Most pull requests should be directed to the [community version](https://github.com/ManimCommunity/manim/).
+Is always welcome.  As mentioned above, the [community edition](https://github.com/ManimCommunity/manim) has the most active ecosystem for contributions, with testing and continuous integration, but pull requests are welcome here too.  Please explain the motivation for a given change and examples of its effect.
+
 
 ## License
-All files in the directory `from_3b1b`, which by and large generate the visuals for 3b1b videos, are copyright 3Blue1Brown.
-
-The general purpose animation code found in the remainder of the repository, on the other hand, is under the MIT license.
+This project falls under the MIT license.

docker-compose.yml

@@ -1,16 +0,0 @@
-version: '3.1'
-
-services:
-  manim:
-    # comment this line if you build the image to prevent overwriting the tag
-    image: eulertour/manim:latest
-    # uncomment this line to build rather than pull the image
-    # build: .
-    entrypoint:
-      - manim
-      - --media_dir=/tmp/output
-    volumes:
-      - ${INPUT_PATH:?INPUT_PATH environment variable isn't set}:/tmp/input
-      - ${OUTPUT_PATH:?OUTPUT_PATH environment variable isn't set}:/tmp/output
-    working_dir: /tmp/input
-    network_mode: "none"

docs/Makefile

@@ -1,9 +1,10 @@
 # Minimal makefile for Sphinx documentation
 #
 
-# You can set these variables from the command line.
-SPHINXOPTS    =
-SPHINXBUILD   = sphinx-build
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
 SOURCEDIR     = source
 BUILDDIR      = build
 
@@ -16,4 +17,4 @@ help:
 # Catch-all target: route all unknown targets to Sphinx using the new
 # "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
 %: Makefile
-	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

docs/example.py

@@ -0,0 +1,37 @@
+from manimlib import *
+
+class SquareToCircle(Scene):
+    def construct(self):
+        circle = Circle()
+        circle.set_fill(BLUE, opacity=0.5)
+        circle.set_stroke(BLUE_E, width=4)
+        square = Square()
+
+        self.play(ShowCreation(square))
+        self.wait()
+        self.play(ReplacementTransform(square, circle))
+        self.wait()
+        # Try typing the following lines
+        # self.play(circle.animate.stretch(4, dim=0))
+        # self.play(Rotate(circle, TAU / 4))
+        # self.play(circle.animate.shift(2 * RIGHT), circle.animate.scale(0.25))
+        # circle.insert_n_curves(10)
+        # self.play(circle.animate.apply_complex_function(lambda z: z**2))
+
+class SquareToCircleEmbed(Scene):
+    def construct(self):
+        circle = Circle()
+        circle.set_fill(BLUE, opacity=0.5)
+        circle.set_stroke(BLUE_E, width=4)
+
+        self.add(circle)
+        self.wait()
+        self.play(circle.animate.stretch(4, dim=0))
+        self.wait(1.5)
+        self.play(Rotate(circle, TAU / 4))
+        self.wait(1.5)
+        self.play(circle.animate.shift(2 * RIGHT), circle.animate.scale(0.25))
+        self.wait(1.5)
+        circle.insert_n_curves(10)
+        self.play(circle.animate.apply_complex_function(lambda z: z**2))
+        self.wait(2)

docs/make.bat

@@ -1,35 +1,35 @@
-@ECHO OFF
-
-pushd %~dp0
-
-REM Command file for Sphinx documentation
-
-if "%SPHINXBUILD%" == "" (
-	set SPHINXBUILD=sphinx-build
-)
-set SOURCEDIR=source
-set BUILDDIR=build
-
-if "%1" == "" goto help
-
-%SPHINXBUILD% >NUL 2>NUL
-if errorlevel 9009 (
-	echo.
-	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
-	echo.installed, then set the SPHINXBUILD environment variable to point
-	echo.to the full path of the 'sphinx-build' executable. Alternatively you
-	echo.may add the Sphinx directory to PATH.
-	echo.
-	echo.If you don't have Sphinx installed, grab it from
-	echo.http://sphinx-doc.org/
-	exit /b 1
-)
-
-%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
-goto end
-
-:help
-%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
-
-:end
-popd
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=source
+set BUILDDIR=build
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd

docs/requirements.txt

@@ -0,0 +1,4 @@
+Sphinx==3.0.3
+sphinx-copybutton
+furo==2020.10.5b9
+Jinja2

docs/source/about.rst

@@ -1,11 +0,0 @@
-About
-=====
-
-Animating technical concepts is traditionally pretty tedious, since it can be
-difficult to make the animations precise enough to convey them accurately.
-``Manim`` uses Python to generate animations programmatically, which makes it
-possible to specify exactly how each one should run.
-
-This project is still very much a work in progress, but I hope that the
-information here will make it easier for newcomers to get started using
-``Manim``.

docs/source/animation.rst

@@ -1,210 +0,0 @@
-Animation
-=========
-
-
-
-The simplest of which is ``Scene.add``. The object appears on the first frame
-without any animation::
-
-  class NoAnimation(Scene):
-      def construct(self):
-          square = Square()
-          self.add(square))
-
-Animation are used in conjunction with ``scene.Play``
-
-Fade
-----
-
-.. raw:: html
-
-    <video width="560" height="315" controls>
-        <source src="_static/AnimationFadeIn.mp4" type="video/mp4">
-    </video>
-
-.. code-block:: python
-
-  class AnimationFadeIn(Scene):
-      def construct(self):
-          square = Square()
-
-          anno = TextMobject("Fade In")
-          anno.shift(2 * DOWN)
-          self.add(anno)
-          self.play(FadeIn(square))
-
-.. raw:: html
-
-    <video width="560" height="315" controls>
-        <source src="_static/AnimationFadeOut.mp4" type="video/mp4">
-    </video>
-
-.. code-block:: python
-
-  class AnimationFadeOut(Scene):
-      def construct(self):
-          square = Square()
-
-          anno = TextMobject("Fade Out")
-          anno.shift(2 * DOWN)
-          self.add(anno)
-          self.add(square)
-          self.play(FadeOut(square))
-
-
-
-.. raw:: html
-
-    <video width="560" height="315" controls>
-        <source src="_static/AnimationFadeInFrom.mp4" type="video/mp4">
-    </video>
-
-.. code-block:: python
-
-  class AnimationFadeInFrom(Scene):
-      def construct(self):
-          square = Square()
-          for label, edge in zip(
-              ["LEFT", "RIGHT", "UP", "DOWN"], [LEFT, RIGHT, UP, DOWN]
-          ):
-              anno = TextMobject(f"Fade In from {label}")
-              anno.shift(2 * DOWN)
-              self.add(anno)
-
-              self.play(FadeInFrom(square, edge))
-              self.remove(anno, square)
-
-
-
-.. raw:: html
-
-    <video width="560" height="315" controls>
-        <source src="_static/AnimationFadeOutAndShift.mp4" type="video/mp4">
-    </video>
-
-.. code-block:: python
-
-  class AnimationFadeOutAndShift(Scene):
-      def construct(self):
-          square = Square()
-          for label, edge in zip(
-              ["LEFT", "RIGHT", "UP", "DOWN"], [LEFT, RIGHT, UP, DOWN]
-          ):
-              anno = TextMobject(f"Fade Out and shift {label}")
-              anno.shift(2 * DOWN)
-              self.add(anno)
-
-              self.play(FadeOutAndShift(square, edge))
-              self.remove(anno, square)
-
-
-
-.. raw:: html
-
-    <video width="560" height="315" controls>
-        <source src="_static/AnimationFadeInFromLarge.mp4" type="video/mp4">
-    </video>
-
-.. code-block:: python
-
-  class AnimationFadeInFromLarge(Scene):
-      def construct(self):
-          square = Square()
-
-          for factor in [0.1, 0.5, 0.8, 1, 2, 5]:
-              anno = TextMobject(f"Fade In from large scale\_factor={factor}")
-              anno.shift(2 * DOWN)
-              self.add(anno)
-
-              self.play(FadeInFromLarge(square, scale_factor=factor))
-              self.remove(anno, square)
-
-.. raw:: html
-
-    <video width="560" height="315" controls>
-        <source src="_static/AnimationFadeInFromPoint.mp4" type="video/mp4">
-    </video>
-
-.. code-block:: python
-
-  class AnimationFadeInFromPoint(Scene):
-      def construct(self):
-          square = Square()
-          for i in range(-6, 7, 2):
-              anno = TextMobject(f"Fade In from point {i}")
-              anno.shift(2 * DOWN)
-              self.add(anno)
-              self.play(FadeInFromPoint(square, point=i))
-              self.remove(anno, square)
-
-
-
-Grow
-----
-
-.. raw:: html
-
-    <video width="560" height="315" controls>
-        <source src="_static/AnimationGrowFromEdge.mp4" type="video/mp4">
-    </video>
-
-.. code-block:: python
-
-  class AnimationGrowFromEdge(Scene):
-      def construct(self):
-
-          for label, edge in zip(
-              ["LEFT", "RIGHT", "UP", "DOWN"], [LEFT, RIGHT, UP, DOWN]
-          ):
-              anno = TextMobject(f"Grow from {label} edge")
-              anno.shift(2 * DOWN)
-              self.add(anno)
-              square = Square()
-              self.play(GrowFromEdge(square, edge))
-              self.remove(anno, square)
-
-
-
-.. raw:: html
-
-    <video width="560" height="315" controls>
-        <source src="_static/AnimationGrowFromCenter.mp4" type="video/mp4">
-    </video>
-
-.. code-block:: python
-
-  class AnimationGrowFromCenter(Scene):
-      def construct(self):
-          square = Square()
-
-          anno = TextMobject("Grow from center")
-          anno.shift(2 * DOWN)
-          self.add(anno)
-
-          self.play(GrowFromCenter(square))
-
-
-
-
-Diagonal Directions
--------------------
-
-You can combine cardinal directions to form diagonal animations
-
-.. raw:: html
-
-    <video width="560" height="315" controls>
-        <source src="_static/AnimationFadeInFromDiagonal.mp4" type="video/mp4">
-    </video>
-
-.. code-block:: python
-
-  class AnimationFadeInFromDiagonal(Scene):
-      def construct(self):
-          square = Square()
-          for diag in [UP + LEFT, UP + RIGHT, DOWN + LEFT, DOWN + RIGHT]:
-              self.play(FadeInFrom(square, diag))
-
-.. note::
-    You can also use the abbreviated forms like ``UL, UR, DL, DR``.
-    See :ref:`ref-directions`.

docs/source/conf.py

@@ -1,53 +1,43 @@
-# Configuration file for the Sphinx documentation builder.
-#
-# This file only contains a selection of the most common options. For a full
-# list see the documentation:
-# http://www.sphinx-doc.org/en/master/config
-
-# -- Path setup --------------------------------------------------------------
-
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-#
-# import os
-# import sys
-# sys.path.insert(0, os.path.abspath('.'))
+import os
+import sys
+sys.path.insert(0, os.path.abspath("."))
+sys.path.insert(0, os.path.abspath('../../'))
 
 
-# -- Project information -----------------------------------------------------
+project = 'manim'
+copyright = '- This document has been placed in the public domain.'
+author = 'TonyCrane'
 
-project = 'Manim'
-copyright = '2019, EulerTour'
-author = 'EulerTour'
+release = ''
 
-
-# -- General configuration ---------------------------------------------------
-master_doc = 'index'
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
 extensions = [
+    'sphinx.ext.todo',
+    'sphinx.ext.githubpages',
+    'sphinx.ext.mathjax',
+    'sphinx.ext.intersphinx',
+    'sphinx.ext.autodoc', 
+    'sphinx.ext.coverage',
+    'sphinx.ext.napoleon',
+    'sphinx_copybutton',
+    'manim_example_ext'
 ]
 
-# Add any paths that contain templates here, relative to this directory.
+autoclass_content = 'both'
+mathjax_path = "https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"
+
 templates_path = ['_templates']
+source_suffix = '.rst'
+master_doc = 'index'
+pygments_style = 'default'
 
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-# This pattern also affects html_static_path and html_extra_path.
-exclude_patterns = []
-
-
-# -- Options for HTML output -------------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-#
-html_theme = 'sphinx_rtd_theme'
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['assets']
+html_static_path = ["_static"]
+html_css_files = [
+    "https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/custom.css", 
+    "https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/colors.css"
+]
+html_theme = 'furo'  # pip install furo==2020.10.5b9
+html_favicon = '_static/icon.png'
+html_logo = '../../logo/transparent_graph.png'
+html_theme_options = {
+    "sidebar_hide_name": True,
+}

docs/source/constants.rst

@@ -1,94 +0,0 @@
-Manim Constants
-===============
-
-The ``constants.py`` under ``manimlib/`` contains variables that are used
-during setup and running manim. Some variables are not documented here as they are
-only used internally by manim.
-
-Directories
------------
-
-    MEDIA_DIR
-              The directory where ``VIDEO_DIR`` and ``TEX_DIR`` will be created,
-              if they aren't specified via flags.
-    VIDEO_DIR
-              Used to store the scenes rendered by Manim. When a scene is
-              finished rendering, it will be stored under
-              ``VIDEO_DIR/module_name/scene_name/quality/scene_name.mp4``.
-              Created under ``MEDIA_DIR`` by default.
-    TEX_DIR
-              Files written by Latex are stored here. It also acts as a cache
-              so that the files aren't rewritten each time Latex is needed.
-
-Those directories are created if they don't exist.
-
-Tex
----
-    TEX_USE_CTEX
-              A boolean value. Change it to True if you need to use Chinese typesetting.
-    TEX_TEXT_TO_REPLACE
-              Placeholder text used by manim when generating tex files
-    TEMPLATE_TEX_FILE
-              By default ``manimlib/tex_template.tex`` is used. If ``TEX_USE_CTEX``
-              is set to True then ``manimlib/ctex_template.tex`` is used.
-
-Numerical Constants
--------------------
-
-    PI
-            alias to ``numpy.pi``
-    TAU
-            PI * 2
-
-    DEGREES
-            TAU / 360
-
-Camera Configuration
---------------------
-
-Render setting presets
-
-    PRODUCTION_QUALITY_CAMERA_CONFIG
-            2560x1440 @ 60fps # This is the default when rendering a scene
-    HIGH_QUALITY_CAMERA_CONFIG
-            1920x1080 @ 60fps. # Used when the ``-h`` or ``--high_quality`` flag
-            is passed.
-    MEDIUM_QUALITY_CAMERA_CONFIG
-            1280x720 @ 30fps. # Used when the ``-m`` or ``--medium_quality``
-            flag is passed.
-    LOW_QUALITY_CAMERA_CONFIG
-            854x480 @ 15fps. # Used when the ``-l`` or ``--low_quality`` flag is
-            passed.
-
-.. _ref-directions:
-
-Coordinates
------------
-
-Used for 2d/3d animations and placements::
-
-    ORIGIN
-    UP
-    DOWN
-    RIGHT
-    LEFT
-    IN # 3d camera only, away from camera
-    OUT # 3d camera only, close to camera
-
-    UL = UP + LEFT # diagonal abbreviations. You can use either one
-    UR = UP + RIGHT
-    DL = DOWN + LEFT
-    DR = DOWN + RIGHT
-
-    TOP
-    BOTTOM
-    LEFT_SIDE
-    RIGHT_SIDE``
-
-Colors
-------
-
-    COLOR_MAP
-            A predefined color maps
-    PALETTE
-            A list of color hex strings, derived from COLOR_MAP

docs/source/coordinate.rst

@@ -1,178 +0,0 @@
-Coordinate
-==========
-
-By default, the scene in manim is made up by 8 x 14 grid. The grid is addressed using a numpy
-array in the form of [x, y, z]. For 2D animations only the x and y axes are used.
-
-.. code-block:: python
-
-  class DotMap(Scene):
-      def construct(self):
-          dots = dict()
-          annos = dict()
-          var_index = 0
-          for x in range(-7, 8):
-              for y in range(-4, 5):
-                  annos[f"{x}{y}"] = TexMobject(f"({x}, {y})")
-                  dots[f"{var_index}"] = Dot(np.array([x, y, 0]))
-                  var_index = var_index + 1
-          for anno, dot in zip(annos.values(), dots.values()):
-              self.add(anno)
-              self.add(dot)
-              self.wait(0.2)
-              self.remove(anno)
-
-.. raw:: html
-
-    <video width="700" height="394" controls>
-        <source src="_static/coordinate/DotMap.mp4" type="video/mp4">
-    </video>
-
-.. note::
-  You can place objects outside this boundary, but it won't show up in the render.
-
-Using Coordinates
------------------
-
-Coordinates are used for creating geometries (`VMobject` in manim) and animations.
-
-Here coordinates are used to create this Polygon
-
-.. code-block:: python
-
-  class CoorPolygon(Scene):
-      def construct(self):
-          for x in range(-7, 8):
-              for y in range(-4, 5):
-                  self.add(Dot(np.array([x, y, 0]), color=DARK_GREY))
-          polygon = Polygon(
-              np.array([3, 2, 0]),
-              np.array([1, -1, 0]),
-              np.array([-5, -4, 0]),
-              np.array([-4, 4, 0]))
-          self.add(polygon)
-
-
-.. Image:: assets/coordinate/CoorPolygon.png
-   :width: 700px
-
-Coordinate Aliasing
--------------------
-
-From some animations typing a ``np.array`` everytime you need a coordinate can be tedious.
-Manim provides aliases to the most common coordinates::
-
-  UP == np.array([0, 1, 0])
-  DOWN == np.array([0, -1, 0])
-  LEFT ==  np.array([-1, 0, 0])
-  RIGHT == np.array([1, 0, 0])
-  UL == np.array([-1, 1, 0])
-  DL == np.array([-1, -1, 0])
-  UR == np.array([1, 1, 0])
-  DR == np.array([1, -1, 0])
-
-Here coordinates are used for animations
-
-.. code-block:: python
-
-  class CoorAlias(Scene):
-      def construct(self):
-          for x in range(-7, 8):
-              for y in range(-4, 5):
-                  self.add(Dot(np.array([x, y, 0]), color=DARK_GREY))
-
-          aliases = {
-              "UP": UP,
-              "np.array([0,1,0])": np.array([0, 1, 0]),
-              "DOWN": DOWN,
-              "np.array([0,-1,0])": np.array([0, -1, 0]),
-              "LEFT": LEFT,
-              "np.array([-1,0,0])": np.array([-1, 0, 0]),
-              "RIGHT": RIGHT,
-              "np.array([1,0,0])": np.array([1, 0, 0]),
-              "UL": UL,
-              "np.array([-1,1,0])": np.array([-1, 1, 0]),
-              "DL": DL,
-              "np.array([-1,-1,0])": np.array([-1, -1, 0]),
-              "UR": UR,
-              "np.array([1,1,0])": np.array([1, 1, 0]),
-              "DR": DR,
-              "np.array([1,-1,0])": np.array([1, -1, 0])}
-          circle = Circle(color=RED, radius=0.5)
-          self.add(circle)
-          self.wait(0.5)
-
-          for text, aliase in aliases.items():
-              anno = TexMobject(f"\\texttt{{{text}}}")
-              self.play(Write(anno, run_time=0.2))
-              self.play(ApplyMethod(circle.shift, aliase))
-              self.wait(0.2)
-              self.play(FadeOut(anno, run_time=0.2))
-
-.. raw:: html
-
-    <video width="700" height="394" controls>
-        <source src="_static/coordinate/CoorAlias.mp4" type="video/mp4">
-    </video>
-
-Coordinate Arithmetic
----------------------
-
-Numpy array allows arithmetic operations::
-
-  >>> numpy.array([2,2,0]) + 4
-  array([6, 6, 4])
-
-  >>> np.array([1, -3, 0]) + np.array([-4, 2, 0])
-  array([-3, -1,  0])
-
-  >>> np.array([2, 2, 0]) - np.array([3,6, 0])
-  array([-1, -4,  0])
-
-  >>> numpy.array([2,2,0]) - 3
-  array([-1, -1, -3])
-
-  >>> np.array([1, -3, 0]) * 3
-  array([ 3, -9,  0])
-
-  >>> numpy.array([2,2,0]) / 2
-  array([1., 1., 0.])
-
-  >>> numpy.array([2,2,0]) / numpy.array([1, 4, 0])
-  __main__:1: RuntimeWarning: invalid value encountered in true_divide
-  array([2. , 0.5, nan])
-
-.. code-block:: python
-
-  class CoorArithmetic(Scene):
-      def construct(self):
-          for x in range(-7, 8):
-              for y in range(-4, 5):
-                  self.add(Dot(np.array([x, y, 0]), color=DARK_GREY))
-
-          circle = Circle(color=RED, radius=0.5)
-          self.add(circle)
-          self.wait(0.5)
-
-          aliases = {
-              "LEFT * 3": LEFT * 3,
-              "UP + RIGHT / 2": UP + RIGHT / 2,
-              "DOWN + LEFT * 2": DOWN + LEFT * 2,
-              "RIGHT * 3.75 * DOWN": RIGHT * 3.75 * DOWN,
-              # certain arithmetic won't work as you expected
-              # In [4]: RIGHT * 3.75 * DOWN
-              # Out[4]: array([ 0., -0.,  0.])
-              "RIGHT * 3.75 + DOWN": RIGHT * 3.75 + DOWN}
-
-          for text, aliase in aliases.items():
-              anno = TexMobject(f"\\texttt{{{text}}}")
-              self.play(Write(anno, run_time=0.2))
-              self.play(ApplyMethod(circle.shift, aliase))
-              self.wait(0.2)
-              self.play(FadeOut(anno, run_time=0.2))
-
-.. raw:: html
-
-    <video width="700" height="394" controls>
-        <source src="_static/coordinate/CoorArithmetic.mp4" type="video/mp4">
-    </video>

docs/source/development/about.rst

@@ -0,0 +1,31 @@
+About
+=====
+
+About Manim
+-----------
+
+Manim is an animation engine for explanatory math videos. 
+You can use it to make math videos (or other fields) like 3Blue1Brown.
+
+There are mainly two versions here:
+
+- `3b1b/manim <https://github.com/3b1b/manim>`_ : Maintained by Grant Sanderson of 3Blue1Brown.
+
+Using OpenGL and its GLSL language to use GPU for rendering. It has higher efficiency, 
+faster rendering speed, and supports real-time rendering and interaction.
+
+- `ManimCommunity/manim <https://github.com/ManimCommunity/manim>`_ : Maintained by Manim Community Dev Team.
+
+Using multiple backend rendering. There is better documentation and 
+a more open contribution community.
+
+About this documentation
+------------------------
+
+This documentation is based on the version in `3b1b/manim <https://github.com/3b1b/manim>`_. 
+Created by `TonyCrane <https://github.com/TonyCrane>`_ ("鹤翔万里" in Chinese) and in production.
+
+Among them, the ``manim_example_ext`` extension for Sphinx refers to 
+`the documentation of ManimCommunity <https://docs.manim.community/>`_.
+
+If you want to contribute to manim or this document, please see: :doc:`contributing`

docs/source/development/changelog.rst

@@ -0,0 +1,307 @@
+Changelog
+=========
+
+v1.6.0
+------
+
+Breaking changes
+^^^^^^^^^^^^^^^^
+- **Python 3.6 is no longer supported** (`#1736 <https://github.com/3b1b/manim/pull/1736>`__)
+
+Fixed bugs
+^^^^^^^^^^
+- Fixed the width of riemann rectangles (`#1762 <https://github.com/3b1b/manim/pull/1762>`__)
+- Bug fixed in cases where empty array is passed to shader (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/fa38b56fd87f713657c7f778f39dca7faf15baa8>`__)
+- Fixed ``AddTextWordByWord`` (`#1772 <https://github.com/3b1b/manim/pull/1772>`__)
+- Fixed ``ControlsExample`` (`#1781 <https://github.com/3b1b/manim/pull/1781>`__)
+
+
+New features
+^^^^^^^^^^^^
+- Added more functions to ``Text`` (details: `#1751 <https://github.com/3b1b/manim/pull/1751>`__)
+- Allowed ``interpolate`` to work on an array of alpha values (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/bf2d9edfe67c7e63ac0107d1d713df7ae7c3fb8f>`__)
+- Allowed ``Numberline.number_to_point`` and ``CoordinateSystem.coords_to_point`` to work on an array of inputs (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/c3e13fff0587d3bb007e71923af7eaf9e4926560>`__)
+- Added a basic ``Prismify`` to turn a flat ``VMobject`` into something with depth (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/f249da95fb65ed5495cd1db1f12ece7e90061af6>`__)
+- Added ``GlowDots``, analogous to ``GlowDot`` (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/e19f35585d817e74b40bc30b1ab7cee84b24da05>`__)
+- Added ``TransformMatchingStrings`` which is compatible with ``Text`` and ``MTex`` (`#1772 <https://github.com/3b1b/manim/pull/1772>`__)
+- Added support for ``substring`` and ``case_sensitive`` parameters for ``LabelledString.get_parts_by_string`` (`#1780 <https://github.com/3b1b/manim/pull/1780>`__) 
+
+
+Refactor
+^^^^^^^^
+- Added type hints (`#1736 <https://github.com/3b1b/manim/pull/1736>`__)
+- Specifid UTF-8 encoding for tex files (`#1748 <https://github.com/3b1b/manim/pull/1748>`__)
+- Refactored ``Text`` with the latest manimpango (`#1751 <https://github.com/3b1b/manim/pull/1751>`__)
+- Reorganized getters for ``ParametricCurve`` (`#1757 <https://github.com/3b1b/manim/pull/1757>`__)
+- Refactored ``CameraFrame`` to use ``scipy.spatial.transform.Rotation`` (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/625460467fdc01fc1b6621cbb3d2612195daedb9>`__)
+- Refactored rotation methods to use ``scipy.spatial.transform.Rotation`` (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/7bf3615bb15cc6d15506d48ac800a23313054c8e>`__)
+- Used ``stroke_color`` to init ``Arrow`` (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/c0b7b55e49f06b75ae133b5a810bebc28c212cd6>`__)
+- Refactored ``Mobject.set_rgba_array_by_color`` (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/8b1f0a8749d91eeda4b674ed156cbc7f8e1e48a8>`__)
+- Made panning more sensitive to mouse movements (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/9d0cc810c5fcb4252990e706c6bf880d571cb1a2>`__)
+- Added loading progress for large SVGs (`#1766 <https://github.com/3b1b/manim/pull/1766>`__)
+- Added getter/setter of ``field_of_view`` for ``CameraFrame`` (`#1770 <https://github.com/3b1b/manim/pull/1770/commits/0610f331a4f7a126a3aae34f8a2a86eabcb692f4>`__)
+- Renamed ``focal_distance`` to ``focal_dist_to_height`` and added getter/setter (`#1770 <https://github.com/3b1b/manim/pull/1770/commits/0610f331a4f7a126a3aae34f8a2a86eabcb692f4>`__)
+- Added getter and setter for ``VMobject.joint_type`` (`#1770 <https://github.com/3b1b/manim/pull/1770/commits/2a7a7ac5189a14170f883533137e8a2ae09aac41>`__)
+- Refactored ``VCube`` (`#1770 <https://github.com/3b1b/manim/pull/1770/commits/0f8d7ed59751d42d5011813ba5694ecb506082f7>`__)
+- Refactored ``Prism`` to receive ``width height depth`` instead of ``dimensions`` (`#1770 <https://github.com/3b1b/manim/pull/1770/commits/0f8d7ed59751d42d5011813ba5694ecb506082f7>`__)
+- Refactored ``Text``, ``MarkupText`` and ``MTex`` based on ``LabelledString`` (`#1772 <https://github.com/3b1b/manim/pull/1772>`__)
+- Refactored ``LabelledString`` and relevant classes (`#1779 <https://github.com/3b1b/manim/pull/1779>`__)
+
+
+v1.5.0
+------
+
+Fixed bugs
+^^^^^^^^^^
+- Bug fix for the case of calling ``Write`` on a null object (`#1740 <https://github.com/3b1b/manim/pull/1740>`__)
+
+
+New features
+^^^^^^^^^^^^
+- Added ``TransformMatchingMTex`` (`#1725 <https://github.com/3b1b/manim/pull/1725>`__)
+- Added ``ImplicitFunction`` (`#1727 <https://github.com/3b1b/manim/pull/1727>`__)
+- Added ``Polyline`` (`#1731 <https://github.com/3b1b/manim/pull/1731>`__)
+- Allowed ``Mobject.set_points`` to take in an empty list, and added ``Mobject.add_point`` (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/a64259158538eae6043566aaf3d3329ff4ac394b>`__)
+- Added ``Scene.refresh_locked_data`` (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/33d2894c167c577a15fdadbaf26488ff1f5bff87>`__)
+- Added presenter mode to scenes with ``-p`` option (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/9a9cc8bdacb7541b7cd4a52ad705abc21f3e27fe>`__ and `#1742 <https://github.com/3b1b/manim/pull/1742>`__)
+- Allowed for an embed by hitting ``ctrl+shift+e`` during interaction (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/9df12fcb7d8360e51cd7021d6877ca1a5c31835e>`__ and `#1746 <https://github.com/3b1b/manim/pull/1746>`__)
+- Added ``Mobject.set_min_width/height/depth`` (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/2798d15591a0375ae6bb9135473e6f5328267323>`__)
+- Allowed ``Mobject.match_coord/x/y/z`` to take in a point (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/29a4d3e82ba94c007c996b2d1d0f923941452698>`__)
+- Added ``text_config`` to ``DecimalNumber`` (`#1744 <https://github.com/3b1b/manim/pull/1744>`__)
+
+
+Refactor
+^^^^^^^^
+- Refactored ``MTex`` (`#1725 <https://github.com/3b1b/manim/pull/1725>`__)
+- Refactored ``SVGMobject`` with svgelements (`#1731 <https://github.com/3b1b/manim/pull/1731>`__)
+- Made sure ``ParametricCurve`` has at least one point (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/2488b9e866fb1ecb842a27dd9f4956ec167e3dee>`__)
+- Set default to no tips on ``Axes`` (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/6c6d387a210756c38feca7d34838aa9ac99bb58a>`__)
+- Stopped displaying when writing tex string is happening (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/58e06e8f6b7c5059ff315d51fd0018fec5cfbb05>`__)
+- Reorganize inheriting order and refactor SVGMobject (`#1745 <https://github.com/3b1b/manim/pull/1745>`__)
+
+
+Dependencies
+^^^^^^^^^^^^
+- Added dependency on ``isosurfaces`` (`#1727 <https://github.com/3b1b/manim/pull/1727>`__)
+- Removed dependency on ``argparse`` since it's a built-in module (`#1728 <https://github.com/3b1b/manim/pull/1728>`__)
+- Removed dependency on ``pyreadline`` (`#1728 <https://github.com/3b1b/manim/pull/1728>`__)
+- Removed dependency on ``cssselect2`` (`#1731 <https://github.com/3b1b/manim/pull/1731>`__)
+- Added dependency on ``svgelements`` (`#1731 <https://github.com/3b1b/manim/pull/1731>`__)
+
+
+v1.4.1
+------
+
+Fixed bugs 
+^^^^^^^^^^
+- Temporarily fixed boolean operations' bug  (`#1724 <https://github.com/3b1b/manim/pull/1724>`__)
+- Import ``Iterable`` from ``collections.abc`` instead of ``collections`` which is deprecated since python 3.9 (`d2e0811 <https://github.com/3b1b/manim/commit/d2e0811285f7908e71a65e664fec88b1af1c6144>`__)
+
+v1.4.0
+------
+
+Fixed bugs
+^^^^^^^^^^
+- Temporarily fixed ``Lightbulb`` (`f1996f8 <https://github.com/3b1b/manim/pull/1697/commits/f1996f8479f9e33d626b3b66e9eb6995ce231d86>`__)
+- Fixed some bugs of ``SVGMobject`` (`#1712 <https://github.com/3b1b/manim/pull/1712>`__)
+- Fixed some bugs of SVG path string parser (`#1717 <https://github.com/3b1b/manim/pull/1717>`__)
+- Fixed some bugs of ``MTex`` (`#1720 <https://github.com/3b1b/manim/pull/1720>`__)
+
+New features
+^^^^^^^^^^^^
+- Added option to add ticks on x-axis in ``BarChart`` (`#1694 <https://github.com/3b1b/manim/pull/1694>`__)
+- Added ``lable_buff`` config parameter for ``Brace`` (`#1704 <https://github.com/3b1b/manim/pull/1704>`__)
+- Added support for ``rotate skewX skewY`` transform in SVG  (`#1712 <https://github.com/3b1b/manim/pull/1712>`__)
+- Added style support to ``SVGMobject`` (`#1717 <https://github.com/3b1b/manim/pull/1717>`__)
+- Added parser to <style> element of SVG  (`#1719 <https://github.com/3b1b/manim/pull/1719>`__)
+- Added support for <line> element in ``SVGMobject`` (`#1719 <https://github.com/3b1b/manim/pull/1719>`__)
+
+Refactor 
+^^^^^^^^
+- Used ``FFMPEG_BIN`` instead of ``"ffmpeg"`` for sound incorporation (`5aa8d15 <https://github.com/3b1b/manim/pull/1697/commits/5aa8d15d85797f68a8f169ca69fd90d441a3abbe>`__)
+- Decorated ``CoordinateSystem.get_axes`` and ``.get_all_ranges`` as abstract method  (`#1709 <https://github.com/3b1b/manim/pull/1709>`__)
+- Refactored SVG path string parser (`#1712 <https://github.com/3b1b/manim/pull/1712>`__)
+- Allowed ``Mobject.scale`` to receive iterable ``scale_factor`` (`#1712 <https://github.com/3b1b/manim/pull/1712>`__)
+- Refactored ``MTex`` (`#1716 <https://github.com/3b1b/manim/pull/1716>`__)
+- Improved config helper (``manimgl --config``) (`#1721 <https://github.com/3b1b/manim/pull/1721>`__)
+- Refactored ``MTex`` (`#1723 <https://github.com/3b1b/manim/pull/1723>`__)
+
+Dependencies
+^^^^^^^^^^^^
+- Added dependency on python package `cssselect2 <https://github.com/Kozea/cssselect2>`__ (`#1719 <https://github.com/3b1b/manim/pull/1719>`__)
+
+
+v1.3.0
+------
+
+Fixed bugs 
+^^^^^^^^^^
+
+- Fixed ``Mobject.stretch_to_fit_depth`` (`#1653 <https://github.com/3b1b/manim/pull/1653>`__)
+- Fixed the bug of rotating camera (`#1655 <https://github.com/3b1b/manim/pull/1655>`__)
+- Fixed ``SurfaceMesh`` to be evenly spaced (`c73d507 <https://github.com/3b1b/manim/pull/1688/commits/c73d507c76af5c8602d4118bc7538ba04c03ebae>`__)
+- Fixed ``angle_between_vectors`` add ``rotation_between_vectors`` (`82bd02d <https://github.com/3b1b/manim/pull/1688/commits/82bd02d21fbd89b71baa21e077e143f440df9014>`__)
+- Fixed ``VMobject.fade`` (`a717314 <https://github.com/3b1b/manim/pull/1688/commits/a7173142bf93fd309def0cc10f3c56f5e6972332>`__)
+- Fixed ``angle_between_vectors`` (`fbc329d <https://github.com/3b1b/manim/pull/1688/commits/fbc329d7ce3b11821d47adf6052d932f7eff724a>`__)
+- Fixed bug in ``ShowSubmobjectsOneByOne`` (`bcd0990 <https://github.com/3b1b/manim/pull/1688/commits/bcd09906bea5eaaa5352e7bee8f3153f434cf606>`__)
+- Fixed bug in ``TransformMatchingParts`` (`7023548 <https://github.com/3b1b/manim/pull/1691/commits/7023548ec62c4adb2f371aab6a8c7f62deb7c33c>`__)
+
+New features
+^^^^^^^^^^^^
+
+- Added CLI flag ``--log-level`` to specify log level (`e10f850 <https://github.com/3b1b/manim/commit/e10f850d0d9f971931cc85d44befe67dc842af6d>`__)
+- Added operations (``+`` and ``*``) for ``Mobject`` (`#1667 <https://github.com/3b1b/manim/pull/1667>`__)
+- Added 4 boolean operations for ``VMobject`` in ``manimlib/mobject/boolean_ops.py`` (`#1675 <https://github.com/3b1b/manim/pull/1675>`__)
+
+  - ``Union(*vmobjects, **kwargs)``  
+  - ``Difference(subject, clip, **kwargs)`` 
+  - ``Intersection(*vmobjects, **kwargs)`` 
+  - ``Exclusion(*vmobjects, **kwargs)`` 
+- Added reflectiveness (`81c3ae3 <https://github.com/3b1b/manim/pull/1688/commits/81c3ae30372e288dc772633dbd17def6e603753e>`__)
+- Enabled ``glow_factor`` on ``DotCloud`` (`2c7689e <https://github.com/3b1b/manim/pull/1688/commits/2c7689ed9e81229ce87c648f97f26267956c0bc9>`__)
+- Added option ``-e`` to insert embed line from the command line (`d065e19 <https://github.com/3b1b/manim/pull/1688/commits/d065e1973d1d6ebd2bece81ce4bdf0c2fff7c772>`__)
+- Improved ``point_from_proportion`` to account for arc length (`0e78027 <https://github.com/3b1b/manim/pull/1688/commits/0e78027186a976f7e5fa8d586f586bf6e6baab8d>`__)
+- Added shortcut ``set_backstroke`` for setting black background stroke (`781a993 <https://github.com/3b1b/manim/pull/1688/commits/781a9934fda6ba11f22ba32e8ccddcb3ba78592e>`__)
+- Added ``Suface.always_sort_to_camera`` (`0b898a5 <https://github.com/3b1b/manim/pull/1688/commits/0b898a5594203668ed9cad38b490ab49ba233bd4>`__)
+- Added getter methods for specific euler angles (`e899604 <https://github.com/3b1b/manim/pull/1688/commits/e899604a2d05f78202fcb3b9824ec34647237eae>`__)
+- Hade ``rotation_between_vectors`` handle identical/similar vectors (`407c53f <https://github.com/3b1b/manim/pull/1688/commits/407c53f97c061bfd8a53beacd88af4c786f9e9ee>`__)
+- Added ``Mobject.insert_submobject`` method (`49743da <https://github.com/3b1b/manim/pull/1688/commits/49743daf3244bfa11a427040bdde8e2bb79589e8>`__)
+- Created single progress display for full scene render (`9dd1f47 <https://github.com/3b1b/manim/pull/1688/commits/9dd1f47dabca1580d6102e34e44574b0cba556e7>`__)
+- Added ``Circle.get_radius`` (`264f7b1 <https://github.com/3b1b/manim/pull/1691/commits/264f7b11726e9e736f0fe472f66e38539f74e848>`__)
+- Added ``Dodecahedron`` (`83841ae <https://github.com/3b1b/manim/pull/1691/commits/83841ae41568a9c9dff44cd163106c19a74ac281>`__)
+- Added ``GlowDot`` (`a1d5147 <https://github.com/3b1b/manim/pull/1691/commits/a1d51474ea1ce3b7aa3efbe4c5e221be70ee2f5b>`__)
+- Added ``MTex`` , see `#1678 <https://github.com/3b1b/manim/pull/1678>`__ for details (`#1678 <https://github.com/3b1b/manim/pull/1678>`__)
+
+Refactor
+^^^^^^^^
+
+- Refactored support for command ``A`` in path of SVG  (`#1662 <https://github.com/3b1b/manim/pull/1662>`__)
+- Refactored ``SingleStringTex.balance_braces`` (`#1662 <https://github.com/3b1b/manim/pull/1662>`__)
+- Slight tweaks to how saturation_factor works on newton-fractal (`8b454fb <https://github.com/3b1b/manim/pull/1688/commits/8b454fbe9335a7011e947093230b07a74ba9c653>`__)
+- Made it possible to set full screen preview as a default (`317a5d6 <https://github.com/3b1b/manim/pull/1688/commits/317a5d6226475b6b54a78db7116c373ef84ea923>`__)
+- Used ``quick_point_from_proportion`` for graph points (`e764da3 <https://github.com/3b1b/manim/pull/1688/commits/e764da3c3adc5ae2a4ce877b340d2b6abcddc2fc>`__)
+- Made sure ``Line.set_length`` returns self (`d2182b9 <https://github.com/3b1b/manim/pull/1688/commits/d2182b9112300558b6c074cefd685f97c10b3898>`__)
+- Better align ``SurfaceMesh`` to the corresponding surface polygons (`eea3c6b <https://github.com/3b1b/manim/pull/1688/commits/eea3c6b29438f9e9325329c4355e76b9f635e97a>`__)
+- Match ``fix_in_frame`` status for ``FlashAround`` mobject (`ee1594a <https://github.com/3b1b/manim/pull/1688/commits/ee1594a3cb7a79b8fc361e4c4397a88c7d20c7e3>`__)
+- Made sure ``Mobject.is_fixed_in_frame`` stays updated with uniforms (`ba23fbe <https://github.com/3b1b/manim/pull/1688/commits/ba23fbe71e4a038201cd7df1d200514ed1c13bc2>`__)
+- Made sure ``skip_animations`` and ``start_at_animation_number`` play well together (`98b0d26 <https://github.com/3b1b/manim/pull/1691/commits/98b0d266d2475926a606331923cca3dc1dea97ad>`__)
+- Updated progress display for full scene render (`f8e6e7d <https://github.com/3b1b/manim/pull/1691/commits/f8e6e7df3ceb6f3d845ced4b690a85b35e0b8d00>`__)
+- ``VectorizedPoint`` should call ``__init__`` for both super classes (`8f1dfab <https://github.com/3b1b/manim/pull/1691/commits/8f1dfabff04a8456f5c4df75b0f97d50b2755003>`__)
+- Used array copy when checking need for refreshing triangulation (`758f329 <https://github.com/3b1b/manim/pull/1691/commits/758f329a06a0c198b27a48c577575d94554305bf>`__)
+
+
+Dependencies
+^^^^^^^^^^^^
+
+- Added dependency on python package `skia-pathops <https://github.com/fonttools/skia-pathops>`__ (`#1675 <https://github.com/3b1b/manim/pull/1675>`__)
+
+v1.2.0
+------
+
+Fixed bugs
+^^^^^^^^^^
+
+- Fixed ``put_start_and_end_on`` in 3D (`#1592 <https://github.com/3b1b/manim/pull/1592>`__)
+- Fixed ``DecimalNumber``'s scaling issue (`#1601 <https://github.com/3b1b/manim/pull/1601>`__)
+- Fixed bug with common range array used for all coordinate systems (`56df154 <https://github.com/3b1b/manim/commit/56df15453f3e3837ed731581e52a1d76d5692077>`__)
+- Fixed ``CoordinateSystem`` init bug (`8645894 <https://github.com/3b1b/manim/commit/86458942550c639a241267d04d57d0e909fcf252>`__)
+- Fixed bug for single-valued ``ValueTracker`` (`0dc096b <https://github.com/3b1b/manim/commit/0dc096bf576ea900b351e6f4a80c13a77676f89b>`__)
+- Fixed bug with SVG rectangles (`54ad355 <https://github.com/3b1b/manim/commit/54ad3550ef0c0e2fda46b26700a43fa8cde0973f>`__)
+- Fixed ``DotCloud.set_radii`` (`d45ea28 <https://github.com/3b1b/manim/commit/d45ea28dc1d92ab9c639a047c00c151382eb0131>`__)
+- Temporarily fixed bug for ``PMobject`` array resizing (`b543cc0 <https://github.com/3b1b/manim/commit/b543cc0e32d45399ee81638b6d4fb631437664cd>`__)
+- Fixed ``match_style`` (`5f878a2 <https://github.com/3b1b/manim/commit/5f878a2c1aa531b7682bd048468c72d2835c7fe5>`__)
+- Fixed negative ``path_arc`` case (`719c81d <https://github.com/3b1b/manim/commit/719c81d72b00dcf49f148d7c146774b22e0fe348>`__)
+- Fixed bug with ``CoordinateSystem.get_lines_parallel_to_axis`` (`c726eb7 <https://github.com/3b1b/manim/commit/c726eb7a180b669ee81a18555112de26a8aff6d6>`__)
+- Fixed ``ComplexPlane`` -i display bug (`7732d2f <https://github.com/3b1b/manim/commit/7732d2f0ee10449c5731499396d4911c03e89648>`__)
+
+New features 
+^^^^^^^^^^^^
+
+- Supported the elliptical arc command ``A`` for ``SVGMobject`` (`#1598 <https://github.com/3b1b/manim/pull/1598>`__)
+- Added ``FlashyFadeIn`` (`#1607 <https://github.com/3b1b/manim/pull/1607>`__)
+- Save triangulation  (`#1607 <https://github.com/3b1b/manim/pull/1607>`__)
+- Added new ``Code`` mobject (`#1625 <https://github.com/3b1b/manim/pull/1625>`__)
+- Add warnings and use rich to display log (`#1637 <https://github.com/3b1b/manim/pull/1637>`__)
+- Added ``VCube`` (`bd356da <https://github.com/3b1b/manim/commit/bd356daa99bfe3134fcb192a5f72e0d76d853801>`__)
+- Supported ``ValueTracker`` to track vectors (`6d72893 <https://github.com/3b1b/manim/commit/6d7289338234acc6658b9377c0f0084aa1fa7119>`__)
+- Added ``set_max_width``, ``set_max_height``, ``set_max_depth`` to ``Mobject`` (`3bb8f3f <https://github.com/3b1b/manim/commit/3bb8f3f0422a5dfba0da6ef122dc0c01f31aff03>`__)
+- Added ``TracgTail`` (`a35dd5a <https://github.com/3b1b/manim/commit/a35dd5a3cbdeffa3891d5aa5f80287c18dba2f7f>`__)
+- Added ``Scene.point_to_mobject`` (`acba13f <https://github.com/3b1b/manim/commit/acba13f4991b78d54c0bf93cce7ca3b351c25476>`__)
+- Added poly_fractal shader (`f84b8a6 <https://github.com/3b1b/manim/commit/f84b8a66fe9e8b3872e5c716c5c240c14bb555ee>`__)
+- Added kwargs to ``TipableVMobject.set_length`` (`b24ba19 <https://github.com/3b1b/manim/commit/b24ba19dec48ba4e38acbde8eec6d3a308b6ab83>`__)
+- Added ``Mobject.replicate`` (`17c2772 <https://github.com/3b1b/manim/commit/17c2772b84abf6392a4170030e36e981de4737d0>`__)
+- Added mandelbrot_fractal shader (`33fa76d <https://github.com/3b1b/manim/commit/33fa76dfac36e70bb5fad69dc6a336800c6dacce>`__)
+- Saved state before each embed (`f22a341 <https://github.com/3b1b/manim/commit/f22a341e8411eae9331d4dd976b5e15bc6db08d9>`__)
+- Allowed releasing of Textures (`e10a752 <https://github.com/3b1b/manim/commit/e10a752c0001e8981038faa03be4de2603d3565f>`__)
+- Consolidated and renamed newton_fractal shader (`14fbed7 <https://github.com/3b1b/manim/commit/14fbed76da4b493191136caebb8a955e2d41265b>`__)
+- Hade ``ImageMoject`` remember the filepath to the Image (`6cdbe0d <https://github.com/3b1b/manim/commit/6cdbe0d67a11ab14a6d84840a114ae6d3af10168>`__)
+
+Refactor
+^^^^^^^^
+
+- Changed back to simpler ``Mobject.scale`` implementation (`#1601 <https://github.com/3b1b/manim/pull/1601>`__)
+- Simplified ``Square`` (`b667db2 <https://github.com/3b1b/manim/commit/b667db2d311a11cbbca2a6ff511d2c3cf1675486>`__)
+- Removed unused parameter ``triangulation_locked`` (`40290ad <https://github.com/3b1b/manim/commit/40290ada8343f10901fa9151cbdf84689667786d>`__)
+- Reimplemented ``Arrow`` (`8647a64 <https://github.com/3b1b/manim/commit/8647a6429dd0c52cba14e971b8c09194a93cfd87>`__)
+- Used ``make_approximately_smooth`` for ``set_points_smoothly`` by default (`d8378d8 <https://github.com/3b1b/manim/commit/d8378d8157040cd797cc47ef9576beffd8607863>`__)
+- Refactored to call ``_handle_scale_side_effects`` after scaling takes place (`7b4199c <https://github.com/3b1b/manim/commit/7b4199c674e291f1b84678828b63b6bd4fcc6b17>`__)
+- Refactored to only call ``throw_error_if_no_points`` once for ``get_start_and_end`` (`7356a36 <https://github.com/3b1b/manim/commit/7356a36fa70a8279b43ae74e247cbd43b2bfd411>`__)
+- Made sure framerate is 30 for previewed scenes (`0787c4f <https://github.com/3b1b/manim/commit/0787c4f36270a6560b50ce3e07b30b0ec5f2ba3e>`__)
+- Pushed ``pixel_coords_to_space_coords`` to ``Window`` (`c635f19 <https://github.com/3b1b/manim/commit/c635f19f2a33e916509e53ded46f55e2afa8f5f2>`__)
+- Refactored to pass tuples and not arrays to uniforms (`d5a88d0 <https://github.com/3b1b/manim/commit/d5a88d0fa457cfcf4cb9db417a098c37c95c7051>`__)
+- Refactored to copy uniform arrays in ``Mobject.copy`` (`9483f26 <https://github.com/3b1b/manim/commit/9483f26a3b056de0e34f27acabd1a946f1adbdf9>`__)
+- Added ``bounding_box`` as exceptional key to point_cloud mobject (`ed1fc4d <https://github.com/3b1b/manim/commit/ed1fc4d5f94467d602a568466281ca2d0368b506>`__)
+- Made sure stroke width is always a float (`329d2c6 <https://github.com/3b1b/manim/commit/329d2c6eaec3d88bfb754b555575a3ea7c97a7e0>`__)
+
+
+v1.1.0
+-------
+
+Fixed bugs
+^^^^^^^^^^
+
+- Fixed the bug of :func:`~manimlib.utils.iterables.resize_with_interpolation` in the case of ``length=0``
+- Fixed the bug of ``__init__`` in :class:`~manimlib.mobject.geometry.Elbow`
+- If chosen monitor is not available, choose one that does exist
+- Make sure mobject data gets unlocked after animations
+- Fixed a bug for off-center vector fields
+- Had ``Mobject.match_points`` return self
+- Fixed chaining animation in example scenes
+- Fixed the default color of tip
+- Fixed a typo in ``ShowPassingFlashWithThinningStrokeWidth``
+- Fixed the default size of ``Text``
+- Fixed a missing import line in ``mobject.py``
+- Fixed the bug in ControlsExample
+- Make sure frame is added to the scene when initialization
+- Fixed zooming directions
+- Rewrote ``earclip_triangulation`` to fix triangulation
+- Allowed sound_file_name to be taken in without extensions
+
+New features
+^^^^^^^^^^^^
+
+- Added :class:`~manimlib.animation.indication.VShowPassingFlash`
+- Added ``COLORMAP_3B1B``
+- Added some methods to coordinate system to access all axes ranges
+  
+  - :meth:`~manimlib.mobject.coordinate_systems.CoordinateSystem.get_origin`
+  - :meth:`~manimlib.mobject.coordinate_systems.CoordinateSystem.get_all_ranges`
+- Added :meth:`~manimlib.mobject.mobject.Mobject.set_color_by_rgba_func`
+- Updated :class:`~manimlib.mobject.vector_field.VectorField` and :class:`~manimlib.mobject.vector_field.StreamLines`
+- Allow ``3b1b_colormap`` as an option for :func:`~manimlib.utils.color.get_colormap_list`
+- Return ``stroke_width`` as 1d array
+- Added :meth:`~manimlib.mobject.svg.text_mobject.Text.get_parts_by_text`
+- Use Text not TexText for Brace
+- Update to Cross to make it default to variable stroke width
+- Added :class:`~manimlib.animation.indication.FlashAround` and :class:`~manimlib.animation.indication.FlashUnder`
+- Allowed configuration in ``Brace.get_text``
+- Added :meth:`~manimlib.camera.camera.CameraFrame.reorient` for quicker changes to frame angle
+- Added ``units`` to :meth:`~manimlib.camera.camera.CameraFrame.set_euler_angles`
+- Allowed any ``VMobject`` to be passed into ``TransformMatchingTex``
+- Removed double brace convention in ``Tex`` and ``TexText``
+- Added support for debugger launch
+- Added CLI flag ``--config_file`` to load configuration file manually
+- Added ``tip_style`` to ``tip_config``
+- Added ``MarkupText``
+- Take in ``u_range`` and ``v_range`` as arguments to ``ParametricSurface``
+- Added ``TrueDot``

docs/source/development/contributing.rst

@@ -0,0 +1,59 @@
+Contributing
+============
+
+Accept any contribution you make :)
+
+- **Contribute to the manim source code**: 
+
+Please fork to your own repository and make changes, submit a pull request, and fill in 
+the motivation for the change following the instructions in the template. We will check 
+your pull request in detail (this usually takes a while, please be patient)
+
+- **Contribute to the documentation**: 
+
+Also submit a pull request and write down the main changes.
+
+- **If you find a bug in the code**: 
+
+Please open an issue and fill in the found problem and your environment according 
+to the template. (But please note that if you think this problem is just a problem 
+of yourself, rather than a problem of source code, it is recommended that you ask a 
+question in the `Q&A category <https://github.com/3b1b/manim/discussions/categories/q-a>`_ 
+of the discussion page)
+
+- **You are welcome to share the content you made with manim**: 
+
+Post it in the `show and tell category <https://github.com/3b1b/manim/discussions/categories/show-and-tell>`_
+of the discussion page.
+
+- **You are also welcome to share some of your suggestions and ideas**: 
+
+Post them in the `ideas category <https://github.com/3b1b/manim/discussions/categories/ideas>`_ 
+of the discussion page.
+
+How to build this documentation
+-------------------------------
+
+- Clone the 3b1b/manim repository
+
+.. code-block:: sh
+
+    git clone https://github.com/3b1b/manim.git
+    # or your own repo
+    # git clone https://github.com/<your user name>/manim.git
+    cd manim
+
+- Install python package dependencies
+
+.. code-block:: sh
+
+    pip install -r docs/requirements.txt
+
+- Go to the ``docs/`` folder and build
+
+.. code-block:: sh
+
+    cd docs/
+    make html
+
+- The output document is located in ``docs/build/html/``

docs/source/documentation/animation/index.rst

@@ -0,0 +1,2 @@
+Animation (TODO)
+================

docs/source/documentation/camera/index.rst

@@ -0,0 +1,2 @@
+Camera (TODO)
+=============

docs/source/documentation/constants.rst

@@ -0,0 +1,190 @@
+constants
+=========
+
+The ``constants.py`` in the ``manimlib`` folder defines the constants 
+needed when running manim. Some constants are not explained here because 
+they are only used inside manim.
+
+Frame and pixel shape
+---------------------
+
+.. code-block:: python
+
+    ASPECT_RATIO = 16.0 / 9.0
+    FRAME_HEIGHT = 8.0
+    FRAME_WIDTH = FRAME_HEIGHT * ASPECT_RATIO
+    FRAME_Y_RADIUS = FRAME_HEIGHT / 2
+    FRAME_X_RADIUS = FRAME_WIDTH / 2
+
+    DEFAULT_PIXEL_HEIGHT = 1080
+    DEFAULT_PIXEL_WIDTH = 1920
+    DEFAULT_FRAME_RATE = 30
+
+Buffs
+-----
+
+.. code-block:: python
+
+    SMALL_BUFF = 0.1
+    MED_SMALL_BUFF = 0.25
+    MED_LARGE_BUFF = 0.5
+    LARGE_BUFF = 1  
+
+    DEFAULT_MOBJECT_TO_EDGE_BUFFER = MED_LARGE_BUFF    # Distance between object and edge
+    DEFAULT_MOBJECT_TO_MOBJECT_BUFFER = MED_SMALL_BUFF # Distance between objects   
+
+Run times
+---------
+
+.. code-block:: python
+
+    DEFAULT_POINTWISE_FUNCTION_RUN_TIME = 3.0
+    DEFAULT_WAIT_TIME = 1.0
+
+Coordinates
+-----------
+
+manim uses three-dimensional coordinates and uses the type of ``ndarray``
+
+.. code-block:: python
+
+    ORIGIN = np.array((0., 0., 0.))
+    UP = np.array((0., 1., 0.))
+    DOWN = np.array((0., -1., 0.))
+    RIGHT = np.array((1., 0., 0.))
+    LEFT = np.array((-1., 0., 0.))
+    IN = np.array((0., 0., -1.))
+    OUT = np.array((0., 0., 1.))
+    X_AXIS = np.array((1., 0., 0.))
+    Y_AXIS = np.array((0., 1., 0.))
+    Z_AXIS = np.array((0., 0., 1.))
+
+    # Useful abbreviations for diagonals
+    UL = UP + LEFT
+    UR = UP + RIGHT
+    DL = DOWN + LEFT
+    DR = DOWN + RIGHT
+
+    TOP = FRAME_Y_RADIUS * UP
+    BOTTOM = FRAME_Y_RADIUS * DOWN
+    LEFT_SIDE = FRAME_X_RADIUS * LEFT
+    RIGHT_SIDE = FRAME_X_RADIUS * RIGHT
+
+Mathematical constant
+---------------------
+
+.. code-block:: python
+
+   PI = np.pi
+   TAU = 2 * PI
+   DEGREES = TAU / 360
+
+Text
+----
+
+.. code-block:: python
+
+    NORMAL = "NORMAL"
+    ITALIC = "ITALIC"
+    OBLIQUE = "OBLIQUE"
+    BOLD = "BOLD"
+
+Stroke width
+------------
+
+.. code-block:: python
+
+    DEFAULT_STROKE_WIDTH = 4
+
+Colours
+-------
+
+Here are the preview of default colours. (Modified from 
+`elteoremadebeethoven <https://elteoremadebeethoven.github.io/manim_3feb_docs.github.io/html/_static/colors/colors.html>`_)
+
+.. raw:: html
+
+    <div style="float: left;">
+    <h3>BLUE</h3>
+    <div class="colors BLUE_E"><p class="color-text">BLUE_E</p></div>
+    <div class="colors BLUE_D"><p class="color-text">BLUE_D</p></div>
+    <div class="colors BLUE_C"><p class="color-text">BLUE_C</p></div>
+    <div class="colors BLUE_B"><p class="color-text">BLUE_B</p></div>
+    <div class="colors BLUE_A"><p class="color-text">BLUE_A</p></div>
+    </div>
+    <div style="float: left;">
+    <h3>TEAL</h3>
+    <div class="colors TEAL_E"><p class="color-text">TEAL_E</p></div>
+    <div class="colors TEAL_D"><p class="color-text">TEAL_D</p></div>
+    <div class="colors TEAL_C"><p class="color-text">TEAL_C</p></div>
+    <div class="colors TEAL_B"><p class="color-text">TEAL_B</p></div>
+    <div class="colors TEAL_A"><p class="color-text">TEAL_A</p></div>
+    </div>
+    <div style="float: left;">
+    <h3>GREEN</h3>
+    <div class="colors GREEN_E"><p class="color-text">GREEN_E</p></div>
+    <div class="colors GREEN_D"><p class="color-text">GREEN_D</p></div>
+    <div class="colors GREEN_C"><p class="color-text">GREEN_C</p></div>
+    <div class="colors GREEN_B"><p class="color-text">GREEN_B</p></div>
+    <div class="colors GREEN_A"><p class="color-text">GREEN_A</p></div>
+    </div>
+    <div style="float: left;">
+    <h3>YELLOW</h3>
+    <div class="colors YELLOW_E"><p class="color-text">YELLOW_E</p></div>
+    <div class="colors YELLOW_D"><p class="color-text">YELLOW_D</p></div>
+    <div class="colors YELLOW_C"><p class="color-text">YELLOW_C</p></div>
+    <div class="colors YELLOW_B"><p class="color-text">YELLOW_B</p></div>
+    <div class="colors YELLOW_A"><p class="color-text">YELLOW_A</p></div>
+    </div>
+    <div style="float: left;">
+    <h3>GOLD</h3>
+    <div class="colors GOLD_E"><p class="color-text">GOLD_E</p></div>
+    <div class="colors GOLD_D"><p class="color-text">GOLD_D</p></div>
+    <div class="colors GOLD_C"><p class="color-text">GOLD_C</p></div>
+    <div class="colors GOLD_B"><p class="color-text">GOLD_B</p></div>
+    <div class="colors GOLD_A"><p class="color-text">GOLD_A</p></div>
+    </div>
+    <div style="float: left;">
+    <h3>RED</h3>
+    <div class="colors RED_E"><p class="color-text">RED_E</p></div>
+    <div class="colors RED_D"><p class="color-text">RED_D</p></div>
+    <div class="colors RED_C"><p class="color-text">RED_C</p></div>
+    <div class="colors RED_B"><p class="color-text">RED_B</p></div>
+    <div class="colors RED_A"><p class="color-text">RED_A</p></div>
+    </div>
+    <div style="float: left;">
+    <h3>MAROON</h3>
+    <div class="colors MAROON_E"><p class="color-text">MAROON_E</p></div>
+    <div class="colors MAROON_D"><p class="color-text">MAROON_D</p></div>
+    <div class="colors MAROON_C"><p class="color-text">MAROON_C</p></div>
+    <div class="colors MAROON_B"><p class="color-text">MAROON_B</p></div>
+    <div class="colors MAROON_A"><p class="color-text">MAROON_A</p></div>
+    </div>
+    <div style="float: left;">
+    <h3>PURPLE</h3>
+    <div class="colors PURPLE_E"><p class="color-text">PURPLE_E</p></div>
+    <div class="colors PURPLE_D"><p class="color-text">PURPLE_D</p></div>
+    <div class="colors PURPLE_C"><p class="color-text">PURPLE_C</p></div>
+    <div class="colors PURPLE_B"><p class="color-text">PURPLE_B</p></div>
+    <div class="colors PURPLE_A"><p class="color-text">PURPLE_A</p></div>
+    </div>
+    <div style="float: left;">
+    <h3>GREY</h3>
+    <div class="colors GREY_E"><p class="color-text">GREY_E</p></div>
+    <div class="colors GREY_D"><p class="color-text">GREY_D</p></div>
+    <div class="colors GREY_C"><p class="color-text">GREY_C</p></div>
+    <div class="colors GREY_B"><p class="color-text">GREY_B</p></div>
+    <div class="colors GREY_A"><p class="color-text">GREY_A</p></div>
+    </div>
+    <div style="float: left;">
+    <h3>Others</h3>
+    <div class="colors WHITE"><p class="color-text" style="color: BLACK">WHITE</p></div>
+    <div class="colors BLACK"><p class="color-text">BLACK</p></div>
+    <div class="colors GREY_BROWN"><p class="color-text-small">GREY_BROWN</p></div>
+    <div class="colors DARK_BROWN"><p class="color-text-small">DARK_BROWN</p></div>
+    <div class="colors LIGHT_BROWN"><p class="color-text-small">LIGHT_BROWN</p></div>
+    <div class="colors PINK"><p class="color-text">PINK</p></div>
+    <div class="colors LIGHT_PINK"><p class="color-text-small">LIGHT_PINK</p></div>
+    <div class="colors GREEN_SCREEN"><p class="color-text-small">GREEN_SCREEN</p></div>
+    <div class="colors ORANGE"><p class="color-text">ORANGE</p></div>
+    </div>

docs/source/documentation/custom_config.rst

@@ -0,0 +1,144 @@
+custom_config
+==============
+
+``directories``
+---------------
+
+- ``mirror_module_path``
+    (``True`` or ``False``) Whether to create a folder named the name of the 
+    running file under the ``output`` path, and save the output (``images/`` 
+    or ``videos/``) in it.
+
+- ``output``
+    Output file path, the videos will be saved in the ``videos/`` folder under it, 
+    and the pictures will be saved in the ``images/`` folder under it.
+
+    For example, if you set ``output`` to ``"/.../manim/output"`` and 
+    ``mirror_module_path`` to ``False``, then you exported ``Scene1`` in the code 
+    file and saved the last frame, then the final directory structure will be like:
+
+    .. code-block:: text
+        :emphasize-lines: 9, 11
+
+            manim/
+            ├── manimlib/
+            │   ├── animation/
+            │   ├── ...
+            │   ├── default_config.yml
+            │   └── window.py
+            ├── output/
+            │   ├── images
+            │   │   └── Scene1.png
+            │   └── videos
+            │       └── Scene1.mp4
+            ├── code.py
+            └── custom_config.yml
+
+    But if you set ``mirror_module_path`` to ``True``, the directory structure will be:
+
+    .. code-block:: text
+        :emphasize-lines: 8
+
+            manim/
+            ├── manimlib/
+            │   ├── animation/
+            │   ├── ...
+            │   ├── default_config.yml
+            │   └── window.py
+            ├── output/
+            │   └── code/
+            │       ├── images
+            │       │   └── Scene1.png
+            │       └── videos
+            │           └── Scene1.mp4
+            ├── code.py
+            └── custom_config.yml
+
+- ``raster_images`` 
+    The directory for storing raster images to be used in the code (including 
+    ``.jpg``, ``.jpeg``, ``.png`` and ``.gif``), which will be read by ``ImageMobject``.
+
+- ``vector_images``
+    The directory for storing vector images to be used in the code (including 
+    ``.svg`` and ``.xdv``), which will be read by ``SVGMobject``.
+
+- ``sounds``
+    The directory for storing sound files to be used in ``Scene.add_sound()`` (
+    including ``.wav`` and ``.mp3``).
+
+- ``temporary_storage``
+    The directory for storing temporarily generated cache files, including 
+    ``Tex`` cache, ``Text`` cache and storage of object points.
+
+``tex``
+-------
+
+- ``executable``
+    The executable program used to compile LaTeX (``latex`` or ``xelatex -no-pdf``
+    is recommended)
+
+- ``template_file``
+    LaTeX template used, in ``manimlib/tex_templates``
+
+- ``intermediate_filetype``
+    The type of intermediate vector file generated after compilation (``dvi`` if 
+    ``latex`` is used, ``xdv`` if ``xelatex`` is used)
+    
+- ``text_to_replace``
+    The text to be replaced in the template (needn't to change)
+
+``universal_import_line``
+-------------------------
+
+Import line that need to execute when entering interactive mode directly.
+
+``style``
+---------
+
+- ``font`` 
+    Default font of Text
+
+- ``background_color``
+    Default background color
+
+``window_position``
+-------------------
+
+The relative position of the playback window on the display (two characters, 
+the first character means upper(U) / middle(O) / lower(D), the second character 
+means left(L) / middle(O) / right(R)).
+
+``window_monitor``
+------------------
+
+The number of the monitor you want the preview window to pop up on. (default is 0)
+
+``break_into_partial_movies``
+-----------------------------
+
+If this is set to ``True``, then many small files will be written corresponding 
+to each ``Scene.play`` and ``Scene.wait`` call, and these files will then be combined
+to form the full scene.  
+
+Sometimes video-editing is made easier when working with the broken up scene, which
+effectively has cuts at all the places you might want.
+
+``camera_qualities``
+--------------------
+
+Export quality
+
+- ``low``
+    Low quality (default is 480p15)
+
+- ``medium``
+    Medium quality (default is 720p30)
+
+- ``high``
+    High quality (default is 1080p30)
+
+- ``ultra_high``
+    Ultra high quality (default is 4K60)
+
+- ``default_quality``
+    Default quality (one of the above four)

docs/source/documentation/mobject/index.rst

@@ -0,0 +1,2 @@
+Mobject (TODO)
+==============

docs/source/documentation/scene/index.rst

@@ -0,0 +1,2 @@
+Scene (TODO)
+============

docs/source/documentation/shaders/index.rst

@@ -0,0 +1,2 @@
+Shaders (TODO)
+==============

docs/source/documentation/utils/index.rst

@@ -0,0 +1,2 @@
+Utils (TODO)
+============

docs/source/getting_started/animating_mobjects.rst

@@ -1,4 +0,0 @@
-Animating Mobjects
-==================
-
-Learn about animations.

docs/source/getting_started/config.rst

@@ -0,0 +1,85 @@
+CONFIG dictionary
+=================
+
+What's CONFIG
+-------------
+
+``CONFIG`` dictionary is a feature of manim, which facilitates the inheritance 
+and modification of parameters between parent and child classes.
+
+| ``CONFIG`` dictionary 's processing is in ``manimlib/utils/config_ops.py``
+| It can convert the key-value pairs in the ``CONFIG`` dictionary into class attributes and values
+
+Generally, the first line of the ``.__init__()`` method in some basic class (``Mobject``, ``Animation``, 
+etc.) will call this function ``digest_config(self, kwargs)`` to convert both 
+the ``CONFIG`` dictionary and ``kwargs`` into attributes. Then it can be accessed 
+directly through ``self.``, which simplifies the handling of inheritance between classes.
+
+**An example**:
+
+There are many class inheritance relationships in ``manimlib/mobject/geometry.py``
+
+.. code-block:: python
+
+    # Line 279
+    class Circle(Arc):
+        CONFIG = {
+            "color": RED,
+            "close_new_points": True,
+            "anchors_span_full_range": False
+        }
+
+.. code-block:: python
+
+    # Line 304
+    class Dot(Circle):
+        CONFIG = {
+            "radius": DEFAULT_DOT_RADIUS,
+            "stroke_width": 0,
+            "fill_opacity": 1.0,
+            "color": WHITE
+        }
+
+The ``Circle`` class uses the key-value pair ``"color": RED`` in the ``CONFIG`` 
+dictionary to add the attribute ``self.color``.
+
+At the same time, the ``Dot`` class also contains the key ``color`` in the 
+``CONFIG`` dictionary, but the value is different. At this time, the priority will 
+modify the attribute ``self.color`` to  ``WHITE``. 
+
+CONFIG nesting
+--------------
+
+The ``CONFIG`` dictionary supports nesting, that is, the value of the key is also 
+a dictionary, for example:
+
+.. code-block:: python
+
+    class Camera(object):
+        CONFIG = {
+            # configs
+        }
+
+.. code-block:: python
+
+    class Scene(object):
+        CONFIG = {
+            "window_config": {},
+            "camera_class": Camera,
+            "camera_config": {},
+            "file_writer_config": {},
+            # other configs
+        }
+
+        def __init__(self, **kwargs):
+            digest_config(self, kwargs)
+            # some lines
+            self.camera = self.camera_class(**self.camera_config)
+
+The ``CONFIG`` dictionary of the ``Camera`` class contains many key-value pairs, 
+and this class needs to be instantiated in the ``Scene`` class. For more convenient 
+control, there is a special key-value pair in the Scene class ``"camera_config": {}``,
+Its value is a dictionary, passed in as ``kwargs`` when initializing the ``Camera`` class 
+to modify the value of the properties of the ``Camera`` class.
+
+So the nesting of the ``CONFIG`` dictionary **essentially** passes in the value as ``kwargs``.

docs/source/getting_started/configuration.rst

@@ -0,0 +1,98 @@
+CLI flags and configuration
+===========================
+
+Command Line Interface
+----------------------
+
+To run manim, you need to enter the directory at the same level as ``manimlib/`` 
+and enter the command in the following format into terminal:
+
+.. code-block:: sh
+
+    manimgl <code>.py <Scene> <flags>
+    # or
+    manim-render <code>.py <Scene> <flags>
+
+- ``<code>.py`` : The python file you wrote. Needs to be at the same level as ``manimlib/``, otherwise you need to use an absolute path or a relative path.
+- ``<Scene>`` : The scene you want to render here. If it is not written or written incorrectly, it will list all for you to choose. And if there is only one ``Scene`` in the file, this class will be rendered directly.
+- ``<flags>`` : CLI flags.
+
+Some useful flags
+^^^^^^^^^^^^^^^^^
+
+- ``-w`` to write the scene to a file.
+- ``-o`` to write the scene to a file and open the result.
+- ``-s`` to skip to the end and just show the final frame. 
+
+  - ``-so`` will save the final frame to an image and show it.
+
+- ``-n <number>`` to skip ahead to the ``n``\ ’th animation of a scene. 
+- ``-f`` to make the playback window fullscreen.
+
+All supported flags
+^^^^^^^^^^^^^^^^^^^
+
+========================================================== ====== =================================================================================================================================================================================================
+flag                                                       abbr   function
+========================================================== ====== =================================================================================================================================================================================================
+``--help``                                                 ``-h`` Show the help message and exit
+``--write_file``                                           ``-w`` Render the scene as a movie file
+``--skip_animations``                                      ``-s`` Skip to the last frame
+``--low_quality``                                          ``-l`` Render at a low quality (for faster rendering)
+``--medium_quality``                                       ``-m`` Render at a medium quality
+``--hd``                                                          Render at a 1080p quality
+``--uhd``                                                         Render at a 4k quality
+``--full_screen``                                          ``-f`` Show window in full screen
+``--presenter_mode``                                       ``-p`` Scene will stay paused during wait calls until space bar or right arrow is hit, like a slide show
+``--save_pngs``                                            ``-g`` Save each frame as a png
+``--save_as_gif``                                          ``-i`` Save the video as gif
+``--transparent``                                          ``-t`` Render to a movie file with an alpha channel
+``--quiet``                                                ``-q``
+``--write_all``                                            ``-a`` Write all the scenes from a file
+``--open``                                                 ``-o`` Automatically open the saved file once its done
+``--finder``                                                      Show the output file in finder
+``--config``                                                      Guide for automatic configuration
+``--file_name FILE_NAME``                                         Name for the movie or image file
+``--start_at_animation_number START_AT_ANIMATION_NUMBER``  ``-n`` Start rendering not from the first animation, but from another, specified by its index. If you passing two comma separated values, e.g. "3,6", it will end the rendering at the second value.
+``--embed LINENO``                                         ``-e`` Takes a line number as an argument, and results in the scene being called as if the line ``self.embed()`` was inserted into the scene code at that line number
+``--resolution RESOLUTION``                                ``-r`` Resolution, passed as "WxH", e.g. "1920x1080"
+``--frame_rate FRAME_RATE``                                       Frame rate, as an integer
+``--color COLOR``                                          ``-c`` Background color
+``--leave_progress_bars``                                         Leave progress bars displayed in terminal
+``--video_dir VIDEO_DIR``                                         Directory to write video
+``--config_file CONFIG_FILE``                                     Path to the custom configuration file
+========================================================== ====== =================================================================================================================================================================================================
+
+custom_config
+--------------
+
+In order to perform more configuration (about directories, etc.) and permanently 
+change the default value (you don't have to add flags to the command every time), 
+you can modify ``custom_config.yml``. The meaning of each option is in 
+page :doc:`../documentation/custom_config`.
+
+You can also use different ``custom_config.yml`` for different directories, such as 
+following the directory structure:
+
+.. code-block:: text
+
+    manim/
+    ├── manimlib/
+    │   ├── animation/
+    │   ├── ...
+    │   ├── default_config.yml
+    │   └── window.py
+    ├── project/
+    │   ├── code.py
+    │   └── custom_config.yml
+    └── custom_config.yml
+
+When you enter the ``project/`` folder and run ``manimgl code.py <Scene>``, 
+it will overwrite ``manim/default_config.yml`` with ``custom_config.yml`` 
+in the ``project`` folder.
+
+Alternatively, you can use ``--config_file`` flag in CLI to specify configuration file manually.
+
+.. code-block:: sh
+
+    manimgl project/code.py --config_file /path/to/custom_config.yml

docs/source/getting_started/example_scenes.rst

@@ -0,0 +1,726 @@
+Example Scenes
+==============
+
+After understanding the previous knowledge, we can understand more scenes.
+Many example scenes are given in ``example_scenes.py``, let's start with
+the simplest and one by one.
+
+InteractiveDevlopment
+---------------------
+
+.. manim-example:: InteractiveDevelopment
+    :media: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/example_scenes/InteractiveDevelopment.mp4
+
+    from manimlib import *
+
+    class InteractiveDevelopment(Scene):
+        def construct(self):
+            circle = Circle()
+            circle.set_fill(BLUE, opacity=0.5)
+            circle.set_stroke(BLUE_E, width=4)
+            square = Square()
+
+            self.play(ShowCreation(square))
+            self.wait()
+
+            # This opens an iPython termnial where you can keep writing
+            # lines as if they were part of this construct method.
+            # In particular, 'square', 'circle' and 'self' will all be
+            # part of the local namespace in that terminal.
+            self.embed()
+
+            # Try copying and pasting some of the lines below into
+            # the interactive shell
+            self.play(ReplacementTransform(square, circle))
+            self.wait()
+            self.play(circle.animate.stretch(4, 0))
+            self.play(Rotate(circle, 90 * DEGREES))
+            self.play(circle.animate.shift(2 * RIGHT).scale(0.25))
+
+            text = Text("""
+                In general, using the interactive shell
+                is very helpful when developing new scenes
+            """)
+            self.play(Write(text))
+
+            # In the interactive shell, you can just type
+            # play, add, remove, clear, wait, save_state and restore,
+            # instead of self.play, self.add, self.remove, etc.
+
+            # To interact with the window, type touch().  You can then
+            # scroll in the window, or zoom by holding down 'z' while scrolling,
+            # and change camera perspective by holding down 'd' while moving
+            # the mouse.  Press 'r' to reset to the standard camera position.
+            # Press 'q' to stop interacting with the window and go back to
+            # typing new commands into the shell.
+
+            # In principle you can customize a scene to be responsive to
+            # mouse and keyboard interactions
+            always(circle.move_to, self.mouse_point)
+
+This scene is similar to what we wrote in :doc:`quickstart`.
+And how to interact has been written in the comments.
+No more explanation here.
+
+AnimatingMethods
+----------------
+
+.. manim-example:: AnimatingMethods
+    :media: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/example_scenes/AnimatingMethods.mp4
+
+    class AnimatingMethods(Scene):
+        def construct(self):
+            grid = Tex(r"\pi").get_grid(10, 10, height=4)
+            self.add(grid)
+
+            # You can animate the application of mobject methods with the
+            # ".animate" syntax:
+            self.play(grid.animate.shift(LEFT))
+
+            # Alternatively, you can use the older syntax by passing the
+            # method and then the arguments to the scene's "play" function:
+            self.play(grid.shift, LEFT)
+
+            # Both of those will interpolate between the mobject's initial
+            # state and whatever happens when you apply that method.
+            # For this example, calling grid.shift(LEFT) would shift the
+            # grid one unit to the left, but both of the previous calls to
+            # "self.play" animate that motion.
+
+            # The same applies for any method, including those setting colors.
+            self.play(grid.animate.set_color(YELLOW))
+            self.wait()
+            self.play(grid.animate.set_submobject_colors_by_gradient(BLUE, GREEN))
+            self.wait()
+            self.play(grid.animate.set_height(TAU - MED_SMALL_BUFF))
+            self.wait()
+
+            # The method Mobject.apply_complex_function lets you apply arbitrary
+            # complex functions, treating the points defining the mobject as
+            # complex numbers.
+            self.play(grid.animate.apply_complex_function(np.exp), run_time=5)
+            self.wait()
+
+            # Even more generally, you could apply Mobject.apply_function,
+            # which takes in functions form R^3 to R^3
+            self.play(
+                grid.animate.apply_function(
+                    lambda p: [
+                        p[0] + 0.5 * math.sin(p[1]),
+                        p[1] + 0.5 * math.sin(p[0]),
+                        p[2]
+                    ]
+                ),
+                run_time=5,
+            )
+            self.wait()
+
+The new usage in this scene is ``.get_grid()`` and ``self.play(mob.animate.method(args))``.
+
+- ``.get_grid()`` method will return a new mobject containing multiple copies of this one arranged in a grid.
+- ``self.play(mob.animate.method(args))`` animates the method, and the details are in the comments above.
+
+TextExample
+-----------
+
+.. manim-example:: TextExample
+    :media: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/example_scenes/TextExample.mp4
+
+    class TextExample(Scene):
+        def construct(self):
+            # To run this scene properly, you should have "Consolas" font in your computer
+            # for full usage, you can see https://github.com/3b1b/manim/pull/680
+            text = Text("Here is a text", font="Consolas", font_size=90)
+            difference = Text(
+                """
+                The most important difference between Text and TexText is that\n
+                you can change the font more easily, but can't use the LaTeX grammar
+                """,
+                font="Arial", font_size=24,
+                # t2c is a dict that you can choose color for different text
+                t2c={"Text": BLUE, "TexText": BLUE, "LaTeX": ORANGE}
+            )
+            VGroup(text, difference).arrange(DOWN, buff=1)
+            self.play(Write(text))
+            self.play(FadeIn(difference, UP))
+            self.wait(3)
+
+            fonts = Text(
+                "And you can also set the font according to different words",
+                font="Arial",
+                t2f={"font": "Consolas", "words": "Consolas"},
+                t2c={"font": BLUE, "words": GREEN}
+            )
+            fonts.set_width(FRAME_WIDTH - 1)
+            slant = Text(
+                "And the same as slant and weight",
+                font="Consolas",
+                t2s={"slant": ITALIC},
+                t2w={"weight": BOLD},
+                t2c={"slant": ORANGE, "weight": RED}
+            )
+            VGroup(fonts, slant).arrange(DOWN, buff=0.8)
+            self.play(FadeOut(text), FadeOut(difference, shift=DOWN))
+            self.play(Write(fonts))
+            self.wait()
+            self.play(Write(slant))
+            self.wait()
+
+The new classes in this scene are ``Text``, ``VGroup``, ``Write``, ``FadeIn`` and ``FadeOut``.
+
+- ``Text`` can create text, define fonts, etc. The usage ais clearly reflected in the above examples.
+- ``VGroup`` can put multiple ``VMobject`` together as a whole. In the example, the ``.arrange()`` method is called to arrange the sub-mobjects in sequence downward (``DOWN``), and the spacing is ``buff``.
+- ``Write`` is an animation that shows similar writing effects.
+- ``FadeIn`` fades the object in, the second parameter indicates the direction of the fade in.
+- ``FadeOut`` fades out the object, the second parameter indicates the direction of the fade out.
+
+TexTransformExample
+-------------------
+
+.. manim-example:: TexTransformExample
+    :media: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/example_scenes/TexTransformExample.mp4
+
+    class TexTransformExample(Scene):
+        def construct(self):
+            to_isolate = ["B", "C", "=", "(", ")"]
+            lines = VGroup(
+                # Passing in muliple arguments to Tex will result
+                # in the same expression as if those arguments had
+                # been joined together, except that the submobject
+                # hierarchy of the resulting mobject ensure that the
+                # Tex mobject has a subject corresponding to
+                # each of these strings.  For example, the Tex mobject
+                # below will have 5 subjects, corresponding to the
+                # expressions [A^2, +, B^2, =, C^2]
+                Tex("A^2", "+", "B^2", "=", "C^2"),
+                # Likewise here
+                Tex("A^2", "=", "C^2", "-", "B^2"),
+                # Alternatively, you can pass in the keyword argument
+                # "isolate" with a list of strings that should be out as
+                # their own submobject.  So the line below is equivalent
+                # to the commented out line below it.
+                Tex("A^2 = (C + B)(C - B)", isolate=["A^2", *to_isolate]),
+                # Tex("A^2", "=", "(", "C", "+", "B", ")", "(", "C", "-", "B", ")"),
+                Tex("A = \\sqrt{(C + B)(C - B)}", isolate=["A", *to_isolate])
+            )
+            lines.arrange(DOWN, buff=LARGE_BUFF)
+            for line in lines:
+                line.set_color_by_tex_to_color_map({
+                    "A": BLUE,
+                    "B": TEAL,
+                    "C": GREEN,
+                })
+
+            play_kw = {"run_time": 2}
+            self.add(lines[0])
+            # The animation TransformMatchingTex will line up parts
+            # of the source and target which have matching tex strings.
+            # Here, giving it a little path_arc makes each part sort of
+            # rotate into their final positions, which feels appropriate
+            # for the idea of rearranging an equation
+            self.play(
+                TransformMatchingTex(
+                    lines[0].copy(), lines[1],
+                    path_arc=90 * DEGREES,
+                ),
+                **play_kw
+            )
+            self.wait()
+
+            # Now, we could try this again on the next line...
+            self.play(
+                TransformMatchingTex(lines[1].copy(), lines[2]),
+                **play_kw
+            )
+            self.wait()
+            # ...and this looks nice enough, but since there's no tex
+            # in lines[2] which matches "C^2" or "B^2", those terms fade
+            # out to nothing while the C and B terms fade in from nothing.
+            # If, however, we want the C^2 to go to C, and B^2 to go to B,
+            # we can specify that with a key map.
+            self.play(FadeOut(lines[2]))
+            self.play(
+                TransformMatchingTex(
+                    lines[1].copy(), lines[2],
+                    key_map={
+                        "C^2": "C",
+                        "B^2": "B",
+                    }
+                ),
+                **play_kw
+            )
+            self.wait()
+
+            # And to finish off, a simple TransformMatchingShapes would work
+            # just fine.  But perhaps we want that exponent on A^2 to transform into
+            # the square root symbol.  At the moment, lines[2] treats the expression
+            # A^2 as a unit, so we might create a new version of the same line which
+            # separates out just the A.  This way, when TransformMatchingTex lines up
+            # all matching parts, the only mismatch will be between the "^2" from
+            # new_line2 and the "\sqrt" from the final line.  By passing in,
+            # transform_mismatches=True, it will transform this "^2" part into
+            # the "\sqrt" part.
+            new_line2 = Tex("A^2 = (C + B)(C - B)", isolate=["A", *to_isolate])
+            new_line2.replace(lines[2])
+            new_line2.match_style(lines[2])
+
+            self.play(
+                TransformMatchingTex(
+                    new_line2, lines[3],
+                    transform_mismatches=True,
+                ),
+                **play_kw
+            )
+            self.wait(3)
+            self.play(FadeOut(lines, RIGHT))
+
+            # Alternatively, if you don't want to think about breaking up
+            # the tex strings deliberately, you can TransformMatchingShapes,
+            # which will try to line up all pieces of a source mobject with
+            # those of a target, regardless of the submobject hierarchy in
+            # each one, according to whether those pieces have the same
+            # shape (as best it can).
+            source = Text("the morse code", height=1)
+            target = Text("here come dots", height=1)
+
+            self.play(Write(source))
+            self.wait()
+            kw = {"run_time": 3, "path_arc": PI / 2}
+            self.play(TransformMatchingShapes(source, target, **kw))
+            self.wait()
+            self.play(TransformMatchingShapes(target, source, **kw))
+            self.wait()
+
+The new classes in this scene are ``Tex``, ``TexText``, ``TransformMatchingTex``
+and ``TransformMatchingShapes``.
+
+- ``Tex`` uses LaTeX to create mathematical formulas.
+- ``TexText`` uses LaTeX to create text.
+- ``TransformMatchingTeX`` automatically transforms sub-objects according to the similarities and differences of tex in ``Tex``.
+- ``TransformMatchingShapes`` automatically transform sub-objects directly based on the similarities and differences of the object point sets.
+
+UpdatersExample
+---------------
+
+.. manim-example:: UpdatersExample
+    :media: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/example_scenes/UpdatersExample.mp4
+
+    class UpdatersExample(Scene):
+        def construct(self):
+            square = Square()
+            square.set_fill(BLUE_E, 1)
+
+            # On all all frames, the constructor Brace(square, UP) will
+            # be called, and the mobject brace will set its data to match
+            # that of the newly constructed object
+            brace = always_redraw(Brace, square, UP)
+
+            text, number = label = VGroup(
+                Text("Width = "),
+                DecimalNumber(
+                    0,
+                    show_ellipsis=True,
+                    num_decimal_places=2,
+                    include_sign=True,
+                )
+            )
+            label.arrange(RIGHT)
+
+            # This ensures that the method deicmal.next_to(square)
+            # is called on every frame
+            always(label.next_to, brace, UP)
+            # You could also write the following equivalent line
+            # label.add_updater(lambda m: m.next_to(brace, UP))
+
+            # If the argument itself might change, you can use f_always,
+            # for which the arguments following the initial Mobject method
+            # should be functions returning arguments to that method.
+            # The following line ensures that decimal.set_value(square.get_y())
+            # is called every frame
+            f_always(number.set_value, square.get_width)
+            # You could also write the following equivalent line
+            # number.add_updater(lambda m: m.set_value(square.get_width()))
+
+            self.add(square, brace, label)
+
+            # Notice that the brace and label track with the square
+            self.play(
+                square.animate.scale(2),
+                rate_func=there_and_back,
+                run_time=2,
+            )
+            self.wait()
+            self.play(
+                square.animate.set_width(5, stretch=True),
+                run_time=3,
+            )
+            self.wait()
+            self.play(
+                square.animate.set_width(2),
+                run_time=3
+            )
+            self.wait()
+
+            # In general, you can alway call Mobject.add_updater, and pass in
+            # a function that you want to be called on every frame.  The function
+            # should take in either one argument, the mobject, or two arguments,
+            # the mobject and the amount of time since the last frame.
+            now = self.time
+            w0 = square.get_width()
+            square.add_updater(
+                lambda m: m.set_width(w0 * math.cos(self.time - now))
+            )
+            self.wait(4 * PI)
+
+The new classes and usage in this scene are ``always_redraw()``, ``DecimalNumber``, ``.to_edge()``,
+``.center()``, ``always()``, ``f_always()``, ``.set_y()`` and ``.add_updater()``.
+
+- ``always_redraw()`` function create a new mobject every frame.
+- ``DecimalNumber`` is a variable number, speed it up by breaking it into ``Text`` characters.
+- ``.to_edge()`` means to place the object on the edge of the screen.
+- ``.center()`` means to place the object in the center of the screen.
+- ``always(f, x)`` means that a certain function (``f(x)``) is executed every frame.
+- ``f_always(f, g)`` is similar to ``always``, executed ``f(g())`` every frame.
+- ``.set_y()`` means to set the ordinate of the object on the screen.
+- ``.add_updater()`` sets an update function for the object. For example: ``mob1.add_updater(lambda mob: mob.next_to(mob2))`` means ``mob1.next_to(mob2)`` is executed every frame.
+
+CoordinateSystemExample
+-----------------------
+
+.. manim-example:: CoordinateSystemExample
+    :media: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/example_scenes/CoordinateSystemExample.mp4
+
+    class CoordinateSystemExample(Scene):
+        def construct(self):
+            axes = Axes(
+                # x-axis ranges from -1 to 10, with a default step size of 1
+                x_range=(-1, 10),
+                # y-axis ranges from -2 to 2 with a step size of 0.5
+                y_range=(-2, 2, 0.5),
+                # The axes will be stretched so as to match the specified
+                # height and width
+                height=6,
+                width=10,
+                # Axes is made of two NumberLine mobjects.  You can specify
+                # their configuration with axis_config
+                axis_config={
+                    "stroke_color": GREY_A,
+                    "stroke_width": 2,
+                },
+                # Alternatively, you can specify configuration for just one
+                # of them, like this.
+                y_axis_config={
+                    "include_tip": False,
+                }
+            )
+            # Keyword arguments of add_coordinate_labels can be used to
+            # configure the DecimalNumber mobjects which it creates and
+            # adds to the axes
+            axes.add_coordinate_labels(
+                font_size=20,
+                num_decimal_places=1,
+            )
+            self.add(axes)
+
+            # Axes descends from the CoordinateSystem class, meaning
+            # you can call call axes.coords_to_point, abbreviated to
+            # axes.c2p, to associate a set of coordinates with a point,
+            # like so:
+            dot = Dot(color=RED)
+            dot.move_to(axes.c2p(0, 0))
+            self.play(FadeIn(dot, scale=0.5))
+            self.play(dot.animate.move_to(axes.c2p(3, 2)))
+            self.wait()
+            self.play(dot.animate.move_to(axes.c2p(5, 0.5)))
+            self.wait()
+
+            # Similarly, you can call axes.point_to_coords, or axes.p2c
+            # print(axes.p2c(dot.get_center()))
+
+            # We can draw lines from the axes to better mark the coordinates
+            # of a given point.
+            # Here, the always_redraw command means that on each new frame
+            # the lines will be redrawn
+            h_line = always_redraw(lambda: axes.get_h_line(dot.get_left()))
+            v_line = always_redraw(lambda: axes.get_v_line(dot.get_bottom()))
+
+            self.play(
+                ShowCreation(h_line),
+                ShowCreation(v_line),
+            )
+            self.play(dot.animate.move_to(axes.c2p(3, -2)))
+            self.wait()
+            self.play(dot.animate.move_to(axes.c2p(1, 1)))
+            self.wait()
+
+            # If we tie the dot to a particular set of coordinates, notice
+            # that as we move the axes around it respects the coordinate
+            # system defined by them.
+            f_always(dot.move_to, lambda: axes.c2p(1, 1))
+            self.play(
+                axes.animate.scale(0.75).to_corner(UL),
+                run_time=2,
+            )
+            self.wait()
+            self.play(FadeOut(VGroup(axes, dot, h_line, v_line)))
+
+            # Other coordinate systems you can play around with include
+            # ThreeDAxes, NumberPlane, and ComplexPlane.
+
+
+GraphExample
+------------
+
+.. manim-example:: GraphExample
+    :media: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/example_scenes/GraphExample.mp4
+
+    class GraphExample(Scene):
+        def construct(self):
+            axes = Axes((-3, 10), (-1, 8))
+            axes.add_coordinate_labels()
+
+            self.play(Write(axes, lag_ratio=0.01, run_time=1))
+
+            # Axes.get_graph will return the graph of a function
+            sin_graph = axes.get_graph(
+                lambda x: 2 * math.sin(x),
+                color=BLUE,
+            )
+            # By default, it draws it so as to somewhat smoothly interpolate
+            # between sampled points (x, f(x)).  If the graph is meant to have
+            # a corner, though, you can set use_smoothing to False
+            relu_graph = axes.get_graph(
+                lambda x: max(x, 0),
+                use_smoothing=False,
+                color=YELLOW,
+            )
+            # For discontinuous functions, you can specify the point of
+            # discontinuity so that it does not try to draw over the gap.
+            step_graph = axes.get_graph(
+                lambda x: 2.0 if x > 3 else 1.0,
+                discontinuities=[3],
+                color=GREEN,
+            )
+
+            # Axes.get_graph_label takes in either a string or a mobject.
+            # If it's a string, it treats it as a LaTeX expression.  By default
+            # it places the label next to the graph near the right side, and
+            # has it match the color of the graph
+            sin_label = axes.get_graph_label(sin_graph, "\\sin(x)")
+            relu_label = axes.get_graph_label(relu_graph, Text("ReLU"))
+            step_label = axes.get_graph_label(step_graph, Text("Step"), x=4)
+
+            self.play(
+                ShowCreation(sin_graph),
+                FadeIn(sin_label, RIGHT),
+            )
+            self.wait(2)
+            self.play(
+                ReplacementTransform(sin_graph, relu_graph),
+                FadeTransform(sin_label, relu_label),
+            )
+            self.wait()
+            self.play(
+                ReplacementTransform(relu_graph, step_graph),
+                FadeTransform(relu_label, step_label),
+            )
+            self.wait()
+
+            parabola = axes.get_graph(lambda x: 0.25 * x**2)
+            parabola.set_stroke(BLUE)
+            self.play(
+                FadeOut(step_graph),
+                FadeOut(step_label),
+                ShowCreation(parabola)
+            )
+            self.wait()
+
+            # You can use axes.input_to_graph_point, abbreviated
+            # to axes.i2gp, to find a particular point on a graph
+            dot = Dot(color=RED)
+            dot.move_to(axes.i2gp(2, parabola))
+            self.play(FadeIn(dot, scale=0.5))
+
+            # A value tracker lets us animate a parameter, usually
+            # with the intent of having other mobjects update based
+            # on the parameter
+            x_tracker = ValueTracker(2)
+            f_always(
+                dot.move_to,
+                lambda: axes.i2gp(x_tracker.get_value(), parabola)
+            )
+
+            self.play(x_tracker.animate.set_value(4), run_time=3)
+            self.play(x_tracker.animate.set_value(-2), run_time=3)
+            self.wait()
+
+SurfaceExample
+--------------
+
+.. manim-example:: SurfaceExample
+    :media: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/example_scenes/SurfaceExample.mp4
+
+    class SurfaceExample(Scene):
+        CONFIG = {
+            "camera_class": ThreeDCamera,
+        }
+
+        def construct(self):
+            surface_text = Text("For 3d scenes, try using surfaces")
+            surface_text.fix_in_frame()
+            surface_text.to_edge(UP)
+            self.add(surface_text)
+            self.wait(0.1)
+
+            torus1 = Torus(r1=1, r2=1)
+            torus2 = Torus(r1=3, r2=1)
+            sphere = Sphere(radius=3, resolution=torus1.resolution)
+            # You can texture a surface with up to two images, which will
+            # be interpreted as the side towards the light, and away from
+            # the light.  These can be either urls, or paths to a local file
+            # in whatever you've set as the image directory in
+            # the custom_config.yml file
+
+            # day_texture = "EarthTextureMap"
+            # night_texture = "NightEarthTextureMap"
+            day_texture = "https://upload.wikimedia.org/wikipedia/commons/thumb/4/4d/Whole_world_-_land_and_oceans.jpg/1280px-Whole_world_-_land_and_oceans.jpg"
+            night_texture = "https://upload.wikimedia.org/wikipedia/commons/thumb/b/ba/The_earth_at_night.jpg/1280px-The_earth_at_night.jpg"
+
+            surfaces = [
+                TexturedSurface(surface, day_texture, night_texture)
+                for surface in [sphere, torus1, torus2]
+            ]
+
+            for mob in surfaces:
+                mob.shift(IN)
+                mob.mesh = SurfaceMesh(mob)
+                mob.mesh.set_stroke(BLUE, 1, opacity=0.5)
+
+            # Set perspective
+            frame = self.camera.frame
+            frame.set_euler_angles(
+                theta=-30 * DEGREES,
+                phi=70 * DEGREES,
+            )
+
+            surface = surfaces[0]
+
+            self.play(
+                FadeIn(surface),
+                ShowCreation(surface.mesh, lag_ratio=0.01, run_time=3),
+            )
+            for mob in surfaces:
+                mob.add(mob.mesh)
+            surface.save_state()
+            self.play(Rotate(surface, PI / 2), run_time=2)
+            for mob in surfaces[1:]:
+                mob.rotate(PI / 2)
+
+            self.play(
+                Transform(surface, surfaces[1]),
+                run_time=3
+            )
+
+            self.play(
+                Transform(surface, surfaces[2]),
+                # Move camera frame during the transition
+                frame.animate.increment_phi(-10 * DEGREES),
+                frame.animate.increment_theta(-20 * DEGREES),
+                run_time=3
+            )
+            # Add ambient rotation
+            frame.add_updater(lambda m, dt: m.increment_theta(-0.1 * dt))
+
+            # Play around with where the light is
+            light_text = Text("You can move around the light source")
+            light_text.move_to(surface_text)
+            light_text.fix_in_frame()
+
+            self.play(FadeTransform(surface_text, light_text))
+            light = self.camera.light_source
+            self.add(light)
+            light.save_state()
+            self.play(light.animate.move_to(3 * IN), run_time=5)
+            self.play(light.animate.shift(10 * OUT), run_time=5)
+
+            drag_text = Text("Try moving the mouse while pressing d or s")
+            drag_text.move_to(light_text)
+            drag_text.fix_in_frame()
+
+            self.play(FadeTransform(light_text, drag_text))
+            self.wait()
+
+This scene shows an example of using a three-dimensional surface, and
+the related usage has been briefly described in the notes.
+
+- ``.fix_in_frame()`` makes the object not change with the view angle of the screen, and is always displayed at a fixed position on the screen.
+
+OpeningManimExample
+-------------------
+
+.. manim-example:: OpeningManimExample
+    :media: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/example_scenes/OpeningManimExample.mp4
+
+
+    class OpeningManimExample(Scene):
+        def construct(self):
+            intro_words = Text("""
+                The original motivation for manim was to
+                better illustrate mathematical functions
+                as transformations.
+            """)
+            intro_words.to_edge(UP)
+
+            self.play(Write(intro_words))
+            self.wait(2)
+
+            # Linear transform
+            grid = NumberPlane((-10, 10), (-5, 5))
+            matrix = [[1, 1], [0, 1]]
+            linear_transform_words = VGroup(
+                Text("This is what the matrix"),
+                IntegerMatrix(matrix, include_background_rectangle=True),
+                Text("looks like")
+            )
+            linear_transform_words.arrange(RIGHT)
+            linear_transform_words.to_edge(UP)
+            linear_transform_words.set_stroke(BLACK, 10, background=True)
+
+            self.play(
+                ShowCreation(grid),
+                FadeTransform(intro_words, linear_transform_words)
+            )
+            self.wait()
+            self.play(grid.animate.apply_matrix(matrix), run_time=3)
+            self.wait()
+
+            # Complex map
+            c_grid = ComplexPlane()
+            moving_c_grid = c_grid.copy()
+            moving_c_grid.prepare_for_nonlinear_transform()
+            c_grid.set_stroke(BLUE_E, 1)
+            c_grid.add_coordinate_labels(font_size=24)
+            complex_map_words = TexText("""
+                Or thinking of the plane as $\\mathds{C}$,\\\\
+                this is the map $z \\rightarrow z^2$
+            """)
+            complex_map_words.to_corner(UR)
+            complex_map_words.set_stroke(BLACK, 5, background=True)
+
+            self.play(
+                FadeOut(grid),
+                Write(c_grid, run_time=3),
+                FadeIn(moving_c_grid),
+                FadeTransform(linear_transform_words, complex_map_words),
+            )
+            self.wait()
+            self.play(
+                moving_c_grid.animate.apply_complex_function(lambda z: z**2),
+                run_time=6,
+            )
+            self.wait(2)
+
+This scene is a comprehensive application of a two-dimensional scene.
+
+After seeing these scenes, you have already understood part of the
+usage of manim. For more examples, see `the video code of 3b1b <https://github.com/3b1b/videos>`_.

docs/source/getting_started/index.rst

@@ -1,18 +0,0 @@
-Getting Started
-===============
-
-Todd Zimmerman put together `a very nice tutorial`_ on getting started with
-``manim``, which has been updated to run on python 3.7. Note that you'll want
-to change `from big_ol_pile_of_manim_imports import *` to `from
-manimlib.imports import *` to work with the current codebase.
-
-.. _a very nice tutorial: https://talkingphysics.wordpress.com/2019/01/08/getting-started-animating-with-manim-and-python-3-7/
-
-.. toctree::
-    :caption: Contents
-    :maxdepth: 2
-
-    learning_by_example
-    mathematical_objects
-    animating_mobjects
-    making_a_scene

docs/source/getting_started/installation.rst

@@ -0,0 +1,69 @@
+Installation
+============
+
+Manim runs on Python 3.7 or higher.
+
+System requirements are：
+
+- `FFmpeg <https://ffmpeg.org/>`__
+- `OpenGL <https://www.opengl.org//>`__ (included in python package ``PyOpenGL``)
+- `LaTeX <https://www.latex-project.org>`__ (optional, if you want to use LaTeX)
+- `Pango <https://pango.org>`__ (only for Linux)
+
+
+Directly
+--------
+
+.. code-block:: sh
+
+   # Install manimgl
+   pip install manimgl
+
+   # Try it out
+   manimgl
+
+If you want to hack on manimlib itself, clone this repository and in
+that directory execute:
+
+.. code-block:: sh
+
+   # Install python requirements
+   pip install -e .
+
+   # Try it out
+   manimgl example_scenes.py OpeningManimExample
+   # or
+   manim-render example_scenes.py OpeningManimExample
+
+If you run the above command and no error message appears, 
+then you have successfully installed all the environments required by manim.
+
+Directly (Windows)
+------------------
+
+1. `Install
+   FFmpeg <https://www.wikihow.com/Install-FFmpeg-on-Windows>`__, and make sure that its path is in the PATH environment variable.
+2. Install a LaTeX distribution.
+   `TeXLive-full <http://tug.org/texlive/>`__ is recommended.
+3. Install the remaining Python packages.
+
+.. code-block:: sh  
+
+   git clone https://github.com/3b1b/manim.git
+   cd manim  
+   pip install -e . 
+   manimgl example_scenes.py OpeningManimExample
+
+For Anaconda
+------------
+
+-  Install FFmpeg and LaTeX as above.
+-  Create a conda environment using
+
+.. code-block:: sh
+   
+   git clone https://github.com/3b1b/manim.git
+   cd manim 
+   conda create -n manim python=3.8
+   conda activate manim
+   pip install -e .

docs/source/getting_started/learning_by_example.rst

@@ -1,131 +0,0 @@
-Learning by Example
-===================
-
-SquareToCircle
---------------
-
-``example_scenes.py`` contains simple examples that we can use to learn about manim.
-
-Go ahead and try out the ``SquareToCircle`` scene by running it with ``$ manim example_scenes.py SquareToCircle -p``
-in manim directory.
-
-.. code-block:: python
-   :linenos:
-
-   from manimlib.imports import *
-
-   class SquareToCircle(Scene):
-       def construct(self):
-           circle = Circle()
-           square = Square()
-           square.flip(RIGHT)
-           square.rotate(-3 * TAU / 8)
-           circle.set_fill(PINK, opacity=0.5)
-
-           self.play(ShowCreation(square))
-           self.play(Transform(square, circle))
-           self.play(FadeOut(square))
-
-.. raw:: html
-
-   <video width="560" height="315" controls>
-       <source src="../_static/SquareToCircle.mp4" type="video/mp4">
-   </video>
-
-
-.. note::
-
-  The flag ``-p`` plays the rendered video with default video player.
-
-  Other frequently used flags are:
-
-    * ``-l`` for rendering video in lower resolution (which renders faster)
-    * ``-s`` to show the last frame of the video.
-
-  Run ``manim -h`` all the available flags (``python -m manim -h`` if you installed it to a venv)
-
-
-Let's step through each line of ``SquareToCircle``
-
-.. code-block:: python
-   :lineno-start: 3
-
-   class SquareToCircle(Scene):
-
-You create videos in manim by writing :class:`~scene.scene.Scene` classes.
-
-Each :class:`~scene.scene.Scene` in manim is self-contained. That means everything
-you created under this scene does not exist outside the class.
-
-.. code-block:: python
-   :lineno-start: 4
-
-   def construct(self):
-
-:meth:`~scene.scene.Scene.construct` specifies what is displayed on the screen
-when the :class:`~scene.scene.Scene` is rendered to video.
-
-.. code-block:: python
-   :lineno-start: 5
-
-   circle = Circle()
-   square = Square()
-
-``Circle()`` and ``Square()`` create :class:`~mobject.geometry.Circle` and :class:`~mobject.geometry.Square`.
-
-Both of these are instances of :class:`~mobject.mobject.Mobject` subclasses, the base class for objects in manim. Note
-that instantiating a :class:`~mobject.mobject.Mobject` does not add it to the
-:class:`~scene.scene.Scene`, so you wouldn't see anything if you were to render
-the :class:`~scene.scene.Scene` at this point.
-
-.. code-block:: python
-   :lineno-start: 7
-
-   square.flip(RIGHT)
-   square.rotate(-3 * TAU / 8)
-   circle.set_fill(PINK, opacity=0.5)
-
-``flip()`` ``rotate()`` ``set_fill()`` apply various modifications to the mobjects before animating
-them.  The call to :meth:`~mobject.mobject.Mobject.flip` flips the
-:class:`~mobject.geometry.Square` across the RIGHT vector.  This is equivalent
-to a refection across the x-axis.
-
-The call to :meth:`~mobject.mobject.Mobject.rotate` rotates the
-:class:`~mobject.geometry.Square` 3/8ths of a full rotation counterclockwise.
-
-The call to :meth:`~mobject.mobject.Mobject.set_fill` sets
-the fill color for the :class:`~mobject.geometry.Circle` to pink, and its opacity to 0.5.
-
-.. code-block:: python
-   :lineno-start: 11
-
-   self.play(ShowCreation(square))
-   self.play(Transform(square, circle))
-   self.play(FadeOut(square))
-
-To generated animation, :class:`~animation.animation.Animation` classes are used.
-
-Each :class:`~animation.animation.Animation` takes one or more :class:`~mobject.mobject.Mobject` instances as arguments, which it animates
-when passed to :meth:`~scene.scene.Scene.play`. This is how video is typically
-created in manim.
-
-:class:`~mobject.mobject.Mobject` instances are automatically
-added to the :class:`~scene.scene.Scene` when they are animated. You can add a
-:class:`~mobject.mobject.Mobject` to the :class:`~scene.scene.Scene` manually
-by passing it as an argument to :meth:`~scene.scene.Scene.add`.
-
-
-:class:`~animation.creation.ShowCreation` draws a :class:`~mobject.mobject.Mobject` to the screen.
-
-:class:`~animation.transform.Transform` morphs one :class:`~mobject.mobject.Mobject` into another.
-
-:class:`~animation.creation.FadeOut` fades a :class:`~mobject.mobject.Mobject` out of the :class:`~scene.scene.Scene`.
-
-.. note::
-
-  Only the first argument to :class:`~animation.transform.Transform` is modified,
-  the second is not added to the :class:`~scene.scene.Scene`. :class:`~animation.tranform.Transform`
-  only changes the appearance but not the underlying properties.
-
-  After the call to ``transform()`` ``square`` is still a :class:`~mobject.geometry.Square` instance
-  but with the shape of :class:`~mobject.geometry.Circle`.

docs/source/getting_started/making_a_scene.rst

@@ -1,15 +0,0 @@
-Making a Scene
-==============
-
-A scene is what renders when manim is executed. Each scene contains mobjects, which can then be animated as
-previously explained. In code, a scene is a class that extends ``Scene`` and implements the ``construct``
-function, like so. Manim will execute this function to render the scene.
-
-.. code-block:: python
-   :linenos:
-
-   from manimlib.imports import *
-
-   class ExampleScene(Scene):
-       def construct(self):
-           # Add and animate mobjects here

docs/source/getting_started/mathematical_objects.rst

@@ -1,13 +0,0 @@
-Mathematical Objects
-====================
-
-Everything that appears on screen in a manim video is a
-:class:`~mobject.mobject.Mobject`, or Mathematical Object. A
-:class:`~mobject.mobject.Mobject`'s appearance is determined by 3
-factors:
-
-* ``m.points``, an Nx3 ``numpy.array`` specifying how to draw ``m``
-* ``m``'s style attributes, such as ``m.color``, ``m.stroke_width``, and
-  ``m.fill_opacity``
-* ``m.submobjects``, a list of :class:`~mobject.mobject.Mobject` instances that
-  are considered part of ``m``

docs/source/getting_started/quickstart.rst

@@ -0,0 +1,256 @@
+Quick Start
+===========
+
+After installing the manim environment according to the instructions on the
+:doc:`installation` page, you can try to make a scene yourself from scratch.
+
+First, create a new ``.py`` file (such as ``start.py``) according to the following
+directory structure:
+
+.. code-block:: text
+    :emphasize-lines: 8
+
+    manim/
+    ├── manimlib/
+    │   ├── animation/
+    │   ├── ...
+    │   ├── default_config.yml
+    │   └── window.py
+    ├── custom_config.yml
+    └── start.py
+
+And paste the following code (I will explain the function of each line in detail later):
+
+.. code-block:: python
+    :linenos:
+
+    from manimlib import *
+
+    class SquareToCircle(Scene):
+        def construct(self):
+            circle = Circle()
+            circle.set_fill(BLUE, opacity=0.5)
+            circle.set_stroke(BLUE_E, width=4)
+
+            self.add(circle)
+
+And run this command:
+
+.. code-block:: sh
+
+    manimgl start.py SquareToCircle
+
+A window will pop up on the screen. And then you can :
+
+- scroll the middle mouse button to move the screen up and down
+- hold down the :kbd:`z` on the keyboard while scrolling the middle mouse button to zoom the screen
+- hold down the :kbd:`s` key on the keyboard and move the mouse to pan the screen
+- hold down the :kbd:`d` key on the keyboard and move the mouse to change the three-dimensional perspective.
+
+Finally, you can close the window and exit the program by pressing :kbd:`q`.
+
+Run this command again:
+
+.. code-block:: sh
+
+    manimgl start.py SquareToCircle -os
+
+At this time, no window will pop up. When the program is finished, this rendered
+image will be automatically opened (saved in the subdirectory ``images/`` of the same
+level directory of ``start.py`` by default):
+
+.. image:: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/quickstart/SquareToCircle.png
+    :align: center
+
+Make an image
+-------------
+
+Next, let's take a detailed look at what each row does.
+
+**Line 1**:
+
+.. code-block:: python
+    
+    from manimlib import *
+    
+This will import all the classes that may be used when using manim.
+
+**Line 3**:
+
+.. code-block:: python
+
+    class SquareToCircle(Scene):
+
+Create a :class:`Scene` subclass ``SquareToCircle``, which will be
+the scene you write and render.
+
+**Line 4**:
+
+.. code-block:: python
+
+    def construct(self):
+
+Write the ``construct()`` method, the content of which will determine
+how to create the mobjects in the screen and what operations need to be performed.
+
+**Line 5**:
+
+.. code-block:: python
+
+    circle = Circle()
+
+Create a circle (an instance of the :class:`Circle` class), called ``circle``
+
+**Line 6~7**:
+
+.. code-block:: python
+
+    circle.set_fill(BLUE, opacity=0.5)
+    circle.set_stroke(BLUE_E, width=4)
+
+Set the circle style by calling the circle's method.
+
+- The ``.set_fill()`` method sets the fill color of this circle to blue (``BLUE``, defined in :doc:`../documentation/constants`), and the fill transparency to 0.5.
+- The ``.set_stroke()`` method sets the stroke color of this circle to dark blue (``BLUE_E``, defined in :doc:`../documentation/constants`), and the stroke width to 4.
+
+**Line 9**:
+
+.. code-block:: python
+
+    self.add(circle)
+
+Add this circle to the screen through the ``.add()`` method of :class:`Scene`.
+
+Add animations
+--------------
+
+Let's change some codes and add some animations to make videos instead of just pictures.
+
+.. code-block:: python
+    :linenos:
+
+    from manimlib import *
+
+    class SquareToCircle(Scene):
+        def construct(self):
+            circle = Circle()
+            circle.set_fill(BLUE, opacity=0.5)
+            circle.set_stroke(BLUE_E, width=4)
+            square = Square()
+
+            self.play(ShowCreation(square))
+            self.wait()
+            self.play(ReplacementTransform(square, circle))
+            self.wait()
+
+Run this command this time:
+
+.. code-block:: sh
+
+    manimgl start.py SquareToCircle
+
+The pop-up window will play animations of drawing a square and transforming
+it into a circle. If you want to save this video, run:
+
+.. code-block:: sh
+    
+    manimgl start.py SquareToCircle -o
+
+This time there will be no pop-up window, but the video file (saved in the subdirectory
+``videos/`` of the same level directory of ``start.py`` by default) will be automatically
+opened after the operation is over:
+
+.. raw:: html
+
+    <video class="manim-video" controls loop autoplay src="https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/quickstart/SquareToCircle.mp4"></video>
+
+Let's take a look at the code this time. The first 7 lines are the same as the previous
+ones, and the 8th line is similar to the 5th line, which creates an instance of the
+:class:`Square` class and named it ``square``.
+
+**Line 10**:
+
+.. code-block:: python
+
+    self.play(ShowCreation(square))
+
+An animation is played through :class:`Scene`'s ``.play()`` method. :class:`ShowCreation`
+is an animation that shows the process of creating a given mobject.
+``self.play(ShowCreation(square))`` is to play the animation of creating ``square``.
+
+**Line 11**:
+
+.. code-block:: python
+
+    self.wait()
+
+Use :class:`Scene`'s ``.wait()`` method to pause (default 1s), you can pass in
+parameters to indicate the pause time (for example, ``self.wait(3)`` means pause for 3s).
+
+**Line 12**:
+
+.. code-block:: python
+
+    self.play(ReplacementTransform(square, circle))
+
+Play the animation that transforms ``square`` into ``circle``.
+``ReplacementTransform(A, B)`` means to transform A into B's pattern and replace A with B.
+
+**Line 13**: Same as line 11, pause for 1s.
+
+
+Enable interaction
+------------------
+
+Interaction is a new feature of the new version. You can add the following line
+at the end of the code to enable interaction:
+
+.. code-block:: python
+
+    self.embed()
+
+Then run ``manimgl start.py SquareToCircle``. 
+
+After the previous animation is executed, the ipython terminal will be opened on
+the command line. After that, you can continue to write code in it, and the statement
+you entered will be executed immediately after pressing :kbd:`Enter`.
+
+For example: input the following lines (without comment lines) into it respectively
+(``self.play`` can be abbreviated as ``play`` in this mode):
+
+.. code-block:: python
+
+    # Stretched 4 times in the vertical direction
+    play(circle.animate.stretch(4, dim=0))
+    # Rotate the ellipse 90°
+    play(Rotate(circle, TAU / 4))
+    # Move 2 units to the right and shrink to 1/4 of the original
+    play(circle.animate.shift(2 * RIGHT), circle.animate.scale(0.25))
+    # Insert 10 curves into circle for non-linear transformation (no animation will play)
+    circle.insert_n_curves(10)
+    # Apply a complex transformation of f(z)=z^2 to all points on the circle
+    play(circle.animate.apply_complex_function(lambda z: z**2))
+    # Close the window and exit the program
+    exit()
+
+You will get an animation similar to the following:
+
+.. raw:: html
+
+    <video class="manim-video" controls loop autoplay src="https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/quickstart/SquareToCircleEmbed.mp4"></video>
+
+If you want to enter the interactive mode directly, you don't have to write an
+empty scene containing only ``self.embed()``, you can directly run the following command
+(this will enter the ipython terminal while the window pops up):
+
+.. code-block:: sh
+
+    manimgl
+
+You succeeded!
+--------------
+
+After reading the above content, you already know how to use manim.
+Below you can see some examples, in the :doc:`example_scenes` page.
+But before that, you'd better have a look at the :doc:`configuration` of manim.
+

docs/source/getting_started/structure.rst

@@ -0,0 +1,128 @@
+Manim's structure
+=================
+
+
+Manim's directory structure
+---------------------------
+
+The manim directory looks very complicated, with a lot of files, 
+but the structure is clear.
+
+Below is the directory structure of manim:
+
+.. code-block:: text
+
+    manimlib/ # manim library
+    ├── __init__.py          
+    ├── __main__.py          
+    ├── default_config.yml   # Default configuration file
+    ├── config.py            # Process CLI flags
+    ├── constants.py         # Defined some constants
+    ├── extract_scene.py     # Extract and run the scene
+    ├── shader_wrapper.py    # Shaders' Wrapper for convenient control
+    ├── window.py            # Playback window
+    ├── tex_templates/ # Templates preset for LaTeX
+    │   ├── tex_templates.tex   # Tex template (will be compiled with latex, default)
+    │   └── ctex_templates.tex  # Tex template that support Chinese (will be compiled with xelatex)
+    ├── camera/
+    │   └── camera.py        # Including Camera and CameraFrame
+    ├── scene/
+    │   ├── scene_file_writer.py     # Used to write scene to video file
+    │   ├── scene.py                 # The basic Scene class
+    │   ├── three_d_scene.py         # Three-dimensional scene
+    │   ├── sample_space_scene.py    # Probability related sample space scene
+    │   └── vector_space_scene.py    # Vector field scene
+    ├── animation/
+    │   ├── animation.py     # The basic class of animation
+    │   ├── composition.py   # Animation group
+    │   ├── creation.py      # Animation related to Create
+    │   ├── fading.py        # Fade related animation
+    │   ├── growing.py       # Animation related to Grow
+    │   ├── indication.py    # Some animations for emphasis
+    │   ├── movement.py      # Animation related to movement
+    │   ├── numbers.py       # Realize changes to DecimalNumber
+    │   ├── rotation.py      # Animation related to rotation
+    │   ├── specialized.py   # Some uncommon animations for special projects
+    │   ├── transform_matching_parts.py # Transform which can automatically match parts
+    │   ├── transform.py     # Some Transforms
+    │   └── update.py        # Realize update from function
+    ├── mobject/
+    │   ├── mobject.py       # The basic class of all math object
+    │   ├── types/ # 4 types of mobject
+    │   │   ├── dot_cloud.py            # Dot cloud (an subclass of PMobject)
+    │   │   ├── image_mobject.py        # Insert pictures
+    │   │   ├── point_cloud_mobject.py  # PMobject (mobject composed of points)
+    │   │   ├── surface.py              # ParametricSurface
+    │   │   └── vectorized_mobject.py   # VMobject (vectorized mobject)
+    │   ├── svg/ # mobject related to svg
+    │   │   ├── svg_mobject.py          # SVGMobject
+    │   │   ├── brace.py                # Brace
+    │   │   ├── drawings.py             # Some special mobject of svg image
+    │   │   ├── tex_mobject.py          # Tex and TexText implemented by LaTeX
+    │   │   └── text_mobject.py         # Text implemented by manimpango
+    │   ├── changing.py             # Dynamically changing mobject
+    │   ├── coordinate_systems.py   # coordinate system
+    │   ├── frame.py                # mobject related to frame
+    │   ├── functions.py            # ParametricFunction
+    │   ├── geometry.py             # geometry mobjects
+    │   ├── matrix.py               # matrix
+    │   ├── mobject_update_utils.py # some defined updater
+    │   ├── number_line.py          # Number line
+    │   ├── numbers.py              # Numbers that can be changed
+    │   ├── probability.py          # mobject related to probability
+    │   ├── shape_matchers.py       # mobject adapted to the size of other objects
+    │   ├── three_dimensions.py     # Three-dimensional objects
+    │   ├── value_tracker.py        # ValueTracker which storage number
+    │   └── vector_field.py         # VectorField
+    ├── once_useful_constructs/  # 3b1b's Common scenes written for some videos
+    │   └── ...
+    ├── shaders/ # GLSL scripts for rendering
+    │   ├── simple_vert.glsl    # a simple glsl script for position
+    │   ├── insert/ # glsl scripts to be inserted in other glsl scripts
+    │   │   ├── NOTE.md   # explain how to insert glsl scripts
+    │   │   └── ...       # useful scripts
+    │   ├── image/ # glsl for images
+    │   │   └── ... # containing shaders for vertex and fragment
+    │   ├── quadratic_bezier_fill/ # glsl for the fill of quadratic bezier curve
+    │   │   └── ... # containing shaders for vertex, fragment and geometry
+    │   ├── quadratic_bezier_stroke/ # glsl for the stroke of quadratic bezier curve
+    │   │   └── ... # containing shaders for vertex, fragment and geometry
+    │   ├── surface/ # glsl for surfaces
+    │   │   └── ... # containing shaders for vertex and fragment
+    │   ├── textured_surface/ # glsl for textured_surface
+    │   │   └── ... # containing shaders for vertex and fragment
+    │   └── true_dot/ # glsl for a dot
+    │       └── ... # containing shaders for vertex, fragment and geometry
+    └── utils/ # Some useful utility functions
+        ├── bezier.py             # For bezier curve
+        ├── color.py              # For color
+        ├── config_ops.py         # Process CONFIG
+        ├── customization.py      # Read from custom_config.yml
+        ├── debug.py              # Utilities for debugging in program
+        ├── directories.py        # Read directories from config file
+        ├── family_ops.py         # Process family members
+        ├── file_ops.py           # Process files and directories
+        ├── images.py             # Read image
+        ├── init_config.py        # Configuration guide
+        ├── iterables.py          # Functions related to list/dictionary processing
+        ├── paths.py              # Curve path
+        ├── rate_functions.py     # Some defined rate_functions
+        ├── simple_functions.py   # Some commonly used functions
+        ├── sounds.py             # Process sounds
+        ├── space_ops.py          # Space coordinate calculation
+        ├── strings.py            # Process strings
+        └── tex_file_writing.py   # Use LaTeX to write strings as svg
+
+Inheritance structure of manim's classes
+----------------------------------------
+
+`Here <https://github.com/3b1b/manim/files/5824383/manim_shaders_structure.pdf>`_ 
+is a pdf showed inheritance structure of manim's classes, large, 
+but basically all classes have included:
+
+.. image:: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/manim_shaders_structure.png
+
+Manim execution process
+-----------------------
+
+.. image:: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/manim_shaders_process_en.png

docs/source/getting_started/whatsnew.rst

@@ -0,0 +1,144 @@
+What's new
+==========
+
+Usage changes of new version manim
+----------------------------------
+
+There are many changes in the new version of manim, and here are only the changes that 
+may have an impact at the code writing level. 
+
+Some of the changes here may not have any major impact on the use, and some changes 
+that affect the use are not mentioned below.
+
+This document is for reference only, see the source code for details.
+
+- ``Animation``
+  
+  - Added ``Fade`` as the parent class of ``FadeIn`` and ``FadeOut``
+  - ``FadeIn`` and ``FadeOut`` can be passed in ``shift`` and ``scale`` parameters
+  - Deleted ``FadeInFrom, FadeInFromDown, FadeOutAndShift, FadeOutAndShiftDown, FadeInFromLarge``, these can be used ``FadeIn, FadeOut`` to achieve the same effect more easily
+  - Added ``FadeTransform`` to cross fade between two objects, and subclass ``FadeTransformPieces``
+  - Added ``CountInFrom(decimal_mob, source_number=0)`` to count ``decimal_mob`` from ``source_number`` to the current value
+  - ``Rotating`` can directly pass in ``angle`` and ``axis`` without writing keywords ``angle=, axis=``
+  - ``Rotate`` has become a subclass of ``Rotating``, and the distortion effect in ``Transform`` will not appear
+  - Removed ``MoveCar`` animation
+  - Added ``TransformMatchingShapes(mobject, target_mobject)`` and ``TransformMatchingTex(mobject, target_mobject)``
+  
+- ``Camera``
+
+  - Removed all camera classes except ``Camera`` (``MappingCamera``, ``MovingCamera``, ``MultiCamera``) and all functions in ``ThreeDCamera``
+  - Implemented ``CameraFrame`` (as a ``Mobject``)
+  
+    - Can be called by ``self.camera.frame`` in ``Scene``
+    - All methods of ``Mobject`` can be used, such as ``.shift()``, ``.scale()``, etc.
+    - Call ``.to_default_state()`` to place in the default position
+    - Set the Euler angles of the camera by ``.set_euler_angles(theta, phi, gamma)``
+    - Set three single Euler angles by ``.set_theta(theta)``, ``.set_phi(phi)``, ``.set_gamma(gamma)``
+    - Use ``.increment_theta(dtheta)``, ``.increment_phi(dphi)``, ``.increment_gamma(gamma)`` to increase the three Euler angles by a certain value. Can be used to realize automatic rotation ``self.camera.frame.add_updater(lambda mob, dt: mob.increment_theta(0.1 * dt))``
+  
+  - ``Camera`` adds a light source, which is a ``Point``, which can be called by ``self.camera.light_source`` in ``Scene`` to move and so on. The default position is ``(- 10, 10, 10)``
+  
+- Delete ``Container``
+- ``Mobject``
+  
+  - ``svg`` related
+  
+    - Added ``Checkmark`` and ``Exmark``
+    - Some unnecessary classes have been removed from ``drawings.py``
+    - Removed ``Code`` and ``Paragraph`` (by mistake)
+    - ``TexMobject`` is renamed to ``Tex``, ``TextMobject`` is renamed to ``TexText``
+    - ``font_size`` has been added to ``Tex``, ``TexText`` and ``Text``
+    - ``Tex`` and ``TexText`` added ``isolate``, which is a list, which will be automatically split
+  
+  - Mobject ``types``
+  
+    - Added a new class ``Surface``, which is the parent class of ``ParametricSurface`` and ``TexturedSurface``.
+    - Added the group ``SGroup`` for ``Surface``
+    - Added ``TexturedSurface(uv_surface, image_file, dark_image_file=None)``, where ``uv_surface`` is a ``Surface``, ``image_file`` is the image to be posted, and ``dark_image_file`` is the image to be posted in the dark (default and ``image_file`` is the same)
+    - Deleted ``Mobject1D``, ``Mobject2D``, ``PointCloudDot``
+    - Added ``DotCloud`` (a ``PMobject``), which has been greatly optimized
+    - Removed ``AbstractImageMobject``, ``ImageMobjectFromCamera``
+    - Removed ``sheen`` from ``VMobject``
+  
+  - ``Mobject``
+  
+    - Added ``gloss`` and ``shadow``, which are the numbers between ``[0, 1]`` respectively. There are four methods of ``.get_gloss()``, ``.set_gloss(gloss)``, ``.get_shadow()``, ``.set_shadow(shadow)``
+    - Added ``.get_grid(n_rows, n_cols)`` to copy into grid
+    - Added ``.set_color_by_code(glsl_code)`` to use GLSL code to change the color
+    - Added ``.set_color_by_xyz_func(glsl_snippet, min_value=-5.0, max_value=5.0, colormap="viridis")`` to pass in GLSL expression in the form of ``x,y,z``, the return value should be a floating point number
+  
+  - Coordinate system (including ``Axes``, ``ThreeDAxes``, ``NumberPlane``, ``ComplexPlane``)
+
+    - No longer use ``x_min``, ``x_max``, ``y_min``, ``y_max``, but use ``x_range``, ``y_range`` as a ``np.array()``, containing three numbers ``np.array([ Minimum, maximum, step size])``
+    - Added the abbreviation ``.i2gp(x, graph)`` of ``.input_to_graph_point(x, graph)``
+    - Added some functions of the original ``GraphScene``
+  
+      - Added ``.get_v_line(point)``, ``.get_h_line(point)`` to return the line from ``point`` to the two coordinate axes, and specify the line type through the keyword argument of ``line_func`` (default ``DashedLine``)
+      - Added ``.get_graph_label(graph, label, x, direction, buff, color)`` to return the label added to the image
+      - Added ``.get_v_line_to_graph(x, graph)``, ``.get_h_line_to_graph(x, graph)`` to return the line from the point with the abscissa of ``x`` on the ``graph`` to the two- axis line
+      - Added ``.angle_of_tangent(x, graph, dx=EPSILON)``, returns the inclination angle of ``graph`` at ``x``
+      - Added ``.slope_of_tangent(x, graph, dx=EPSILON)``, returns the slope of tangent line of ``graph`` at ``x``
+      - Added ``.get_tangent_line(x, graph, length=5)`` to return the tangent line of ``graph`` at ``x``
+      - Added ``.get_riemann_rectangles(graph, x_range, dx, input_sample_type, ...)`` to return Riemann rectangles (a ``VGroup``)
+  
+    - The attribute ``number_line_config`` of ``Axes`` is renamed to ``axis_config``
+    - ``Axes`` original ``.get_coordinate_labels(x_values, y_values)`` method was renamed to ``.add_coordinate_labels(x_values, y_values)`` (but it is not added to the screen)
+    - ``.add_coordinate_labels(numbers)`` of ``ComplexPlane`` will directly add the coordinates to the screen
+  
+  - ``NumberLine``
+  
+    - No longer use ``x_min``, ``x_max``, ``tick_frequency``, but use ``x_range``, which is an array containing three numbers ``[min, max, step]``
+    - The original ``label_direction`` attribute changed to the ``line_to_number_direction`` attribute
+    - Replace ``tip_width`` and ``tip_height`` with ``tip_config`` (dictionary) attributes
+    - The original ``exclude_zero_from_default`` attribute is modified to the ``numbers_to_exclude`` attribute (default is None)
+    - The original ``.add_tick_marks()`` method was changed to the ``.add_ticks()`` method
+    - Delete the ``.get_number_mobjects(*numbers)`` method, only use the ``.add_numbers(x_values=None, excluding=None)`` method
+  
+  - Three-dimensional objects
+  
+    - Added ``SurfaceMesh(uv_surface)``, pass in a ``Surface`` to generate its uv mesh
+    - ``ParametricSurface`` no longer uses ``u_min, u_max, v_min, v_max``, but instead uses ``u_range, v_range``, which is a tuple (``(min, max)``), and ``resolution`` can be set larger, don’t worry Speed ​​issue
+    - Added ``Torus``, controlled by ``r1, r2`` keyword parameters
+    - Added ``Cylinder``, controlled by ``height, radius`` keyword parameters
+    - Added ``Line3D`` (extremely thin cylinder), controlled by the ``width`` keyword parameter
+    - Added ``Disk3D``, controlled by ``radius`` keyword parameter
+    - Add ``Square3D``, controlled by ``side_length`` keyword parameter
+    - Improved ``Cube`` and ``Prism``, the usage remains unchanged
+  
+  - Other objects
+  
+    - ``ParametricFunction`` is renamed to ``ParametricCurve``. Instead of using ``t_min, t_max, step_size``, use ``t_range``, which is an array of three numbers (``[t_min, t_max, step_size]``). ``dt`` was renamed to ``epsilon``. Other usage remains unchanged
+    - All ``TipableVMobject`` can pass in ``tip_length`` to control the style of ``tip``
+    - ``Line`` adds ``.set_points_by_ends(start, end, buff=0, path_arc=0)`` method
+    - ``Line`` added ``.get_projection(point)`` to return the projection position of ``point`` on a straight line
+    - ``Arrow`` adds three attributes of ``thickness, tip_width_ratio, tip_angle``
+    - ``CubicBezier`` is changed to ``a0, h0, h1, a1``, that is, only a third-order Bezier curve is supported
+    - ``Square`` can be initialized directly by passing in ``side_length`` instead of using the keyword ``side_length=``
+    - ``always_redraw(func, *args, **kwargs)`` supports incoming parameters ``*args, **kwargs``
+    - The ``digit_to_digit_buff`` property of ``DecimalNumber`` has been renamed to ``digit_buff_per_font_unit``, and the ``.scale()`` method has been improved
+    - ``ValueTracker`` adds ``value_type`` attribute, the default is ``np.float64``
+  
+- ``Scene``
+  
+  - Removed all functions of ``GraphScene`` (moved to ``once_useful_constructs``), ``MovingCameraScene``, ``ReconfigurableScene``, ``SceneFromVideo``, ``ZoomedScene``, and ``ThreeDScene``. Because these can basically be achieved by adjusting ``CameraFrame`` (``self.camera.frame``)
+  - Currently ``SampleSpaceScene`` and ``VectorScene`` have not been changed for the new version, so it is not recommended to use (only ``Scene`` is recommended)
+  - Fix the export of gif, just use the ``-i`` option directly
+  - Added the ``.interact()`` method, during which the mouse and keyboard can be used to continue the interaction, which will be executed by default after the scene ends
+  - Added ``.embed()`` method, open iPython terminal to enter interactive mode
+  - Added ``.save_state()`` method to save the current state of the scene
+  - Added ``.restore()`` method to restore the entire scene to the saved state
+  
+- ``utils``
+  
+  - A series of functions related to second-order Bezier have been added to ``utils/bezier.py``
+  - Added a function to read color map from ``matplotlib`` in ``utils/color.py``
+  - Added a series of related functions for processing folders/custom styles/object families
+  - ``resize_array``, ``resize_preserving_order``, ``resize_with_interpolation`` three functions have been added to ``utils/iterables.py``
+  - The definition of ``smooth`` is updated in ``utils/rate_functions.py``
+  - ``clip(a, min_a, max_a)`` function has been added to ``utils/simple_functions.py``
+  - Some functions have been improved in ``utils/space_ops.py``, some functions for space calculation, and functions for processing triangulation have been added
+  
+- ``constants``
+  
+  - Fixed the aspect ratio of the screen to 16:9
+  - Deleted the old gray series (``LIGHT_GREY``, ``GREY``, ``DARK_GREY``, ``DARKER_GREY``), added a new series of gray ``GREY_A`` ~ ``GREY_E``

docs/source/index.rst

@@ -1,30 +1,36 @@
-.. Manim documentation master file, created by
-   sphinx-quickstart on Mon May 27 14:19:19 2019.
-   You can adapt this file completely to your liking, but it should at least
-   contain the root `toctree` directive.
+Manim's documentation
+=====================
 
-Welcome to Manim's documentation!
-=================================
+.. image:: https://cdn.jsdelivr.net/gh/3b1b/manim@master/logo/white_with_name.png
 
-These docs are generated from the master branch of the
-`Manim repo <https://github.com/3b1b/manim>`_. You can contribute by submitting
-a pull request there.
+Manim is an animation engine for explanatory math videos. It's used to create precise animations programmatically, as seen in the videos
+at `3Blue1Brown <https://www.3blue1brown.com/>`_.
+
+And here is a Chinese version of this documentation: https://docs.manim.org.cn/
 
 .. toctree::
-    :maxdepth: 2
-    :caption: Contents
+   :maxdepth: 2
+   :caption: Getting Started
 
-    about
-    installation/index
-    getting_started/index
-    coordinate
-    animation
-    constants
+   getting_started/installation
+   getting_started/quickstart
+   getting_started/configuration
+   getting_started/example_scenes
+   getting_started/config
+   getting_started/structure
+   getting_started/whatsnew
 
+.. toctree::
+   :maxdepth: 2
+   :caption: Documentation
 
-Indices and tables
-==================
+   documentation/constants
+   documentation/custom_config
 
-* :ref:`genindex`
-* :ref:`modindex`
-* :ref:`search`
+.. toctree::
+   :maxdepth: 2
+   :caption: Development
+
+   development/changelog
+   development/contributing
+   development/about

docs/source/installation/index.rst

@@ -1,12 +0,0 @@
-Installation
-============
-
-Instructions on installing Manim
-
-.. toctree::
-    :maxdepth: 2
-    :caption: Contents
-
-    linux
-    mac
-    windows

docs/source/installation/linux.rst

@@ -1,64 +0,0 @@
-Linux
-=====
-
-Ubuntu
-------
-
-Install system libraries::
-
-    # apt install sox ffmpeg libcairo2 libcairo2-dev
-
-Install Latex distribution::
-
-    # apt install texlive-full
-
-Install manim via pypi::
-
-    # pip3 install manimlib
-
-OR Install manim via the git repository with venv::
-
-    $ git clone https://github.com/3b1b/manim
-    $ cd manim
-    $ python3 -m venv ./
-    $ source bin/activate
-    $ pip3 install -r requirement.txt
-
-To use manim in virtual environment you need to activate the environment with
-the ``activate`` binary by doing ``source bin/activate``, to exit use the ``deactivate`` command.
-
-.. note:: The git repository is updated first before the one on pypi. The git repository also
-          includes project files used to produce 3b1b videos. Some of the old projects might not
-          work as due to api changes.
-
-
-.. note:: The required latex packages are dictated by
-          ``manimlib/tex_template.tex`` which ``texlive-full`` will satisfy. The download size
-          can be quite large. If you wish to install only the packages required to use
-          manim, substitude ``texlive-full`` with::
-
-            texlive texlive-latex-extra texlive-fonts-extra
-            texlive-latex-recommended texlive-science texlive-fonts-extra tipa
-
-Arch Linux
-----------
-Install system libraries::
-
-    # pacman -S cairo ffmpeg opencv sox
-
-Install Latex distribution::
-
-    # pacman -S texlive-most
-
-OR install python-manimlib_:sup:`AUR` package::
-
-    $ git clone https://aur.archlinux.org/python-manimlib.git
-    $ cd python-manimlib
-    $ makepkg -si
-
-You can use AUR helpers such as yay_:sup:`AUR`::
-
-    $ yay -S python-manimlib
-
-.. _python-manimlib: https://aur.archlinux.org/packages/python-manimlib/
-.. _yay: https://aur.archlinux.org/packages/yay/

docs/source/installation/mac.rst

@@ -1,12 +0,0 @@
-Mac
-===
-
-The simplest way to install the system dependencies on Mac OS X is with Homebrew.
-Mac come preinstalled with python2, but to use manim, python3 is required
-
-1. Install python3 https://docs.python.org/3/using/mac.html
-2. Install Cairo: ``brew install cairo``
-3. Install Sox: ``brew install sox``
-4. Install ffmpeg: ``brew install ffmpeg``
-5. Install latex (MacTeX): ``brew cask install mactex``
-6. Install manimlib ``pip install manimlib`` (or ``pip install --user manimlib`` to just yourself)

docs/source/installation/windows.rst

@@ -1,60 +0,0 @@
-Windows
-=======
-
-Install System Libraries
-------------------------
-
-Make sure you have *Python 3* for Windows installed first:
-
-https://www.python.org/downloads/windows/
-
-Install ffmpeg:
-
-https://ffmpeg.org/download.html#build-windows
-
-Install sox:
-
-http://sox.sourceforge.net/Main/HomePage
-
-Install a latex distribution. On Windows MikTex is commonly used:
-
-https://miktex.org/howto/install-miktex
-
-Path configuration
-------------------
-
-To invoke commandline without supplying path to the binary
-the PATH environment needs to be configured. Below are template examples, please change
-the path according to your username and specific python version. Assuming all the
-softwares are installed with no alteration to the installation paths::
-
-  C:\Users\$username\AppData\local\Programs\Python\Python$version\
-  C:\Users\$username\AppData\local\Programs\Python\Python$version\Scripts\
-  C:\MikTex\miktex\bin\x64\
-  C:\ffmpeg\bin\
-
-The path entries should be separated by semicolon.
-
-Installing python packages and manim
-------------------------------------
-
-Make sure you can start pip using ``pip`` in your commandline. Then do
-``pip install pyreadline`` for the ``readline`` package.
-
-Grab the pycairo wheel binary ``pycairo‑1.18.0‑cp37‑cp37m‑win32.whl`` from https://www.lfd.uci.edu/~gohlke/pythonlibs/#pycairo
-and install it via ``python -m pip install C:\absolute\path\to\the\whl\file``
-
-clone the manim repository if you have git ``git clone https://github.com/3b1b/manim`` or download the zip file from
-the repository page with ``Clone or download`` button and unzip it.
-
-Open the commandline within the manim directory with ``Shift + Right click`` on an empty space in the folder and select ``open command window here``
-
-Install manim python dependencies with ``pip install -r requirements.txt``
-
-Test the installation
----------------------
-
-Type in ``python -m manim -h`` and if nothing went wrong during the installation process you should see the help text.
-
-Use ``python -m manim example_scenes.py SquareToCircle -pl`` to render the example scene and the file should play after rendering. The movie file should be
-in ``media/videos/example_scenes/480p15``

docs/source/manim_example_ext.py

@@ -0,0 +1,108 @@
+from docutils import nodes
+from docutils.parsers.rst import directives, Directive
+
+import jinja2
+import os
+
+
+class skip_manim_node(nodes.Admonition, nodes.Element):
+    pass
+
+
+def visit(self, node, name=""):
+    self.visit_admonition(node, name)
+
+
+def depart(self, node):
+    self.depart_admonition(node)
+
+
+class ManimExampleDirective(Directive):
+    has_content = True
+    required_arguments = 1
+    optional_arguments = 0
+    option_spec = {
+        "hide_code": bool,
+        "media": str,
+    }
+    final_argument_whitespace = True
+
+    def run(self):
+        hide_code = "hide_code" in self.options
+        scene_name = self.arguments[0]
+        media_file_name = self.options["media"]
+
+        source_block = [
+            ".. code-block:: python",
+            "",
+            *["    " + line for line in self.content],
+        ]
+        source_block = "\n".join(source_block)
+
+        state_machine = self.state_machine
+        document = state_machine.document
+
+        if any(media_file_name.endswith(ext) for ext in [".png", ".jpg", ".gif"]):
+            is_video = False
+        else:
+            is_video = True
+
+        rendered_template = jinja2.Template(TEMPLATE).render(
+            scene_name=scene_name,
+            scene_name_lowercase=scene_name.lower(),
+            hide_code=hide_code,
+            is_video=is_video,
+            media_file_name=media_file_name,
+            source_block=source_block,
+        )
+        state_machine.insert_input(
+            rendered_template.split("\n"), source=document.attributes["source"]
+        )
+
+        return []
+
+
+def setup(app):
+    app.add_node(skip_manim_node, html=(visit, depart))
+
+    setup.app = app
+    setup.config = app.config
+    setup.confdir = app.confdir
+
+    app.add_directive("manim-example", ManimExampleDirective)
+
+    metadata = {"parallel_read_safe": False, "parallel_write_safe": True}
+    return metadata
+
+
+TEMPLATE = r"""
+{% if not hide_code %}
+
+.. raw:: html
+
+    <div class="manim-example">
+
+{% endif %}
+
+{% if is_video %}
+.. raw:: html
+
+    <video id="{{ scene_name_lowercase }}" class="manim-video" controls loop autoplay src="{{ media_file_name }}"></video>
+{% else %}
+.. image:: {{ media_file_name }}
+    :align: center
+    :name: {{ scene_name_lowercase }}
+{% endif %}
+
+{% if not hide_code %}
+.. raw:: html
+
+    <h5 class="example-header">{{ scene_name }}<a class="headerlink" href="#{{ scene_name_lowercase }}">¶</a></h5>
+
+{{ source_block }}
+{% endif %}
+
+.. raw:: html
+
+    </div>
+"""

environment.yml

@@ -1,20 +0,0 @@
-name: manim
-channels:
-  - defaults
-  - conda-forge
-dependencies:
-  - python=3.7
-  - cairo
-  - ffmpeg
-  - colour==0.1.5
-  - numpy==1.15.0
-  - pillow==5.2.0
-  - scipy==1.1.0
-  - tqdm==4.24.0
-  - opencv==3.4.2
-  - pycairo==1.18.0
-  - pydub==0.23.0
-  - ffmpeg
-  - pygments==2.6.1
-  - pip:
-      - pyreadline

example_scenes.py

@@ -1,136 +1,674 @@
-#!/usr/bin/env python
-
-from manimlib.imports import *
+from manimlib import *
+import numpy as np
 
 # To watch one of these scenes, run the following:
-# python -m manim example_scenes.py SquareToCircle -pl
-#
-# Use the flag -l for a faster rendering at a lower
-# quality.
+# manimgl example_scenes.py OpeningManimExample
 # Use -s to skip to the end and just save the final frame
-# Use the -p to have the animation (or image, if -s was
-# used) pop up once done.
+# Use -w to write the animation to a file
+# Use -o to write it to a file and open it once done
 # Use -n <number> to skip ahead to the n'th animation of a scene.
-# Use -r <number> to specify a resolution (for example, -r 1080
-# for a 1920x1080 video)
 
 
 class OpeningManimExample(Scene):
     def construct(self):
-        title = TextMobject("This is some \\LaTeX")
-        basel = TexMobject(
-            "\\sum_{n=1}^\\infty "
-            "\\frac{1}{n^2} = \\frac{\\pi^2}{6}"
+        intro_words = Text("""
+            The original motivation for manim was to
+            better illustrate mathematical functions
+            as transformations.
+        """)
+        intro_words.to_edge(UP)
+
+        self.play(Write(intro_words))
+        self.wait(2)
+
+        # Linear transform
+        grid = NumberPlane((-10, 10), (-5, 5))
+        matrix = [[1, 1], [0, 1]]
+        linear_transform_words = VGroup(
+            Text("This is what the matrix"),
+            IntegerMatrix(matrix, include_background_rectangle=True),
+            Text("looks like")
         )
-        VGroup(title, basel).arrange(DOWN)
+        linear_transform_words.arrange(RIGHT)
+        linear_transform_words.to_edge(UP)
+        linear_transform_words.set_stroke(BLACK, 10, background=True)
+
         self.play(
-            Write(title),
-            FadeInFrom(basel, UP),
+            ShowCreation(grid),
+            FadeTransform(intro_words, linear_transform_words)
         )
         self.wait()
-
-        transform_title = TextMobject("That was a transform")
-        transform_title.to_corner(UP + LEFT)
-        self.play(
-            Transform(title, transform_title),
-            LaggedStart(*map(FadeOutAndShiftDown, basel)),
-        )
+        self.play(grid.animate.apply_matrix(matrix), run_time=3)
         self.wait()
 
-        grid = NumberPlane()
-        grid_title = TextMobject("This is a grid")
-        grid_title.scale(1.5)
-        grid_title.move_to(transform_title)
+        # Complex map
+        c_grid = ComplexPlane()
+        moving_c_grid = c_grid.copy()
+        moving_c_grid.prepare_for_nonlinear_transform()
+        c_grid.set_stroke(BLUE_E, 1)
+        c_grid.add_coordinate_labels(font_size=24)
+        complex_map_words = TexText("""
+            Or thinking of the plane as $\\mathds{C}$,\\\\
+            this is the map $z \\rightarrow z^2$
+        """)
+        complex_map_words.to_corner(UR)
+        complex_map_words.set_stroke(BLACK, 5, background=True)
 
-        self.add(grid, grid_title)  # Make sure title is on top of grid
         self.play(
-            FadeOut(title),
-            FadeInFromDown(grid_title),
-            ShowCreation(grid, run_time=3, lag_ratio=0.1),
-        )
-        self.wait()
-
-        grid_transform_title = TextMobject(
-            "That was a non-linear function \\\\"
-            "applied to the grid"
-        )
-        grid_transform_title.move_to(grid_title, UL)
-        grid.prepare_for_nonlinear_transform()
-        self.play(
-            grid.apply_function,
-            lambda p: p + np.array([
-                np.sin(p[1]),
-                np.sin(p[0]),
-                0,
-            ]),
-            run_time=3,
+            FadeOut(grid),
+            Write(c_grid, run_time=3),
+            FadeIn(moving_c_grid),
+            FadeTransform(linear_transform_words, complex_map_words),
         )
         self.wait()
         self.play(
-            Transform(grid_title, grid_transform_title)
+            moving_c_grid.animate.apply_complex_function(lambda z: z**2),
+            run_time=6,
         )
-        self.wait()
+        self.wait(2)
 
 
-class SquareToCircle(Scene):
+class AnimatingMethods(Scene):
     def construct(self):
-        circle = Circle()
-        square = Square()
-        square.flip(RIGHT)
-        square.rotate(-3 * TAU / 8)
-        circle.set_fill(PINK, opacity=0.5)
+        grid = Tex(r"\pi").get_grid(10, 10, height=4)
+        self.add(grid)
 
-        self.play(ShowCreation(square))
-        self.play(Transform(square, circle))
-        self.play(FadeOut(square))
+        # You can animate the application of mobject methods with the
+        # ".animate" syntax:
+        self.play(grid.animate.shift(LEFT))
 
+        # Alternatively, you can use the older syntax by passing the
+        # method and then the arguments to the scene's "play" function:
+        self.play(grid.shift, LEFT)
 
-class WarpSquare(Scene):
-    def construct(self):
-        square = Square()
-        self.play(ApplyPointwiseFunction(
-            lambda point: complex_to_R3(np.exp(R3_to_complex(point))),
-            square
-        ))
+        # Both of those will interpolate between the mobject's initial
+        # state and whatever happens when you apply that method.
+        # For this example, calling grid.shift(LEFT) would shift the
+        # grid one unit to the left, but both of the previous calls to
+        # "self.play" animate that motion.
+
+        # The same applies for any method, including those setting colors.
+        self.play(grid.animate.set_color(YELLOW))
+        self.wait()
+        self.play(grid.animate.set_submobject_colors_by_gradient(BLUE, GREEN))
+        self.wait()
+        self.play(grid.animate.set_height(TAU - MED_SMALL_BUFF))
+        self.wait()
+
+        # The method Mobject.apply_complex_function lets you apply arbitrary
+        # complex functions, treating the points defining the mobject as
+        # complex numbers.
+        self.play(grid.animate.apply_complex_function(np.exp), run_time=5)
+        self.wait()
+
+        # Even more generally, you could apply Mobject.apply_function,
+        # which takes in functions form R^3 to R^3
+        self.play(
+            grid.animate.apply_function(
+                lambda p: [
+                    p[0] + 0.5 * math.sin(p[1]),
+                    p[1] + 0.5 * math.sin(p[0]),
+                    p[2]
+                ]
+            ),
+            run_time=5,
+        )
         self.wait()
 
 
-class WriteStuff(Scene):
+class TextExample(Scene):
     def construct(self):
-        example_text = TextMobject(
-            "This is some text",
-            tex_to_color_map={"text": YELLOW}
+        # To run this scene properly, you should have "Consolas" font in your computer
+        # for full usage, you can see https://github.com/3b1b/manim/pull/680
+        text = Text("Here is a text", font="Consolas", font_size=90)
+        difference = Text(
+            """
+            The most important difference between Text and TexText is that\n
+            you can change the font more easily, but can't use the LaTeX grammar
+            """,
+            font="Arial", font_size=24,
+            # t2c is a dict that you can choose color for different text
+            t2c={"Text": BLUE, "TexText": BLUE, "LaTeX": ORANGE}
         )
-        example_tex = TexMobject(
-            "\\sum_{k=1}^\\infty {1 \\over k^2} = {\\pi^2 \\over 6}",
-        )
-        group = VGroup(example_text, example_tex)
-        group.arrange(DOWN)
-        group.set_width(FRAME_WIDTH - 2 * LARGE_BUFF)
+        VGroup(text, difference).arrange(DOWN, buff=1)
+        self.play(Write(text))
+        self.play(FadeIn(difference, UP))
+        self.wait(3)
 
-        self.play(Write(example_text))
-        self.play(Write(example_tex))
+        fonts = Text(
+            "And you can also set the font according to different words",
+            font="Arial",
+            t2f={"font": "Consolas", "words": "Consolas"},
+            t2c={"font": BLUE, "words": GREEN}
+        )
+        fonts.set_width(FRAME_WIDTH - 1)
+        slant = Text(
+            "And the same as slant and weight",
+            font="Consolas",
+            t2s={"slant": ITALIC},
+            t2w={"weight": BOLD},
+            t2c={"slant": ORANGE, "weight": RED}
+        )
+        VGroup(fonts, slant).arrange(DOWN, buff=0.8)
+        self.play(FadeOut(text), FadeOut(difference, shift=DOWN))
+        self.play(Write(fonts))
+        self.wait()
+        self.play(Write(slant))
+        self.wait()
+
+
+class TexTransformExample(Scene):
+    def construct(self):
+        to_isolate = ["B", "C", "=", "(", ")"]
+        lines = VGroup(
+            # Passing in muliple arguments to Tex will result
+            # in the same expression as if those arguments had
+            # been joined together, except that the submobject
+            # hierarchy of the resulting mobject ensure that the
+            # Tex mobject has a subject corresponding to
+            # each of these strings.  For example, the Tex mobject
+            # below will have 5 subjects, corresponding to the
+            # expressions [A^2, +, B^2, =, C^2]
+            Tex("A^2", "+", "B^2", "=", "C^2"),
+            # Likewise here
+            Tex("A^2", "=", "C^2", "-", "B^2"),
+            # Alternatively, you can pass in the keyword argument
+            # "isolate" with a list of strings that should be out as
+            # their own submobject.  So the line below is equivalent
+            # to the commented out line below it.
+            Tex("A^2 = (C + B)(C - B)", isolate=["A^2", *to_isolate]),
+            # Tex("A^2", "=", "(", "C", "+", "B", ")", "(", "C", "-", "B", ")"),
+            Tex("A = \\sqrt{(C + B)(C - B)}", isolate=["A", *to_isolate])
+        )
+        lines.arrange(DOWN, buff=LARGE_BUFF)
+        for line in lines:
+            line.set_color_by_tex_to_color_map({
+                "A": BLUE,
+                "B": TEAL,
+                "C": GREEN,
+            })
+
+        play_kw = {"run_time": 2}
+        self.add(lines[0])
+        # The animation TransformMatchingTex will line up parts
+        # of the source and target which have matching tex strings.
+        # Here, giving it a little path_arc makes each part sort of
+        # rotate into their final positions, which feels appropriate
+        # for the idea of rearranging an equation
+        self.play(
+            TransformMatchingTex(
+                lines[0].copy(), lines[1],
+                path_arc=90 * DEGREES,
+            ),
+            **play_kw
+        )
+        self.wait()
+
+        # Now, we could try this again on the next line...
+        self.play(
+            TransformMatchingTex(lines[1].copy(), lines[2]),
+            **play_kw
+        )
+        self.wait()
+        # ...and this looks nice enough, but since there's no tex
+        # in lines[2] which matches "C^2" or "B^2", those terms fade
+        # out to nothing while the C and B terms fade in from nothing.
+        # If, however, we want the C^2 to go to C, and B^2 to go to B,
+        # we can specify that with a key map.
+        self.play(FadeOut(lines[2]))
+        self.play(
+            TransformMatchingTex(
+                lines[1].copy(), lines[2],
+                key_map={
+                    "C^2": "C",
+                    "B^2": "B",
+                }
+            ),
+            **play_kw
+        )
+        self.wait()
+
+        # And to finish off, a simple TransformMatchingShapes would work
+        # just fine.  But perhaps we want that exponent on A^2 to transform into
+        # the square root symbol.  At the moment, lines[2] treats the expression
+        # A^2 as a unit, so we might create a new version of the same line which
+        # separates out just the A.  This way, when TransformMatchingTex lines up
+        # all matching parts, the only mismatch will be between the "^2" from
+        # new_line2 and the "\sqrt" from the final line.  By passing in,
+        # transform_mismatches=True, it will transform this "^2" part into
+        # the "\sqrt" part.
+        new_line2 = Tex("A^2 = (C + B)(C - B)", isolate=["A", *to_isolate])
+        new_line2.replace(lines[2])
+        new_line2.match_style(lines[2])
+
+        self.play(
+            TransformMatchingTex(
+                new_line2, lines[3],
+                transform_mismatches=True,
+            ),
+            **play_kw
+        )
+        self.wait(3)
+        self.play(FadeOut(lines, RIGHT))
+
+        # Alternatively, if you don't want to think about breaking up
+        # the tex strings deliberately, you can TransformMatchingShapes,
+        # which will try to line up all pieces of a source mobject with
+        # those of a target, regardless of the submobject hierarchy in
+        # each one, according to whether those pieces have the same
+        # shape (as best it can).
+        source = Text("the morse code", height=1)
+        target = Text("here come dots", height=1)
+
+        self.play(Write(source))
+        self.wait()
+        kw = {"run_time": 3, "path_arc": PI / 2}
+        self.play(TransformMatchingShapes(source, target, **kw))
+        self.wait()
+        self.play(TransformMatchingShapes(target, source, **kw))
         self.wait()
 
 
 class UpdatersExample(Scene):
     def construct(self):
-        decimal = DecimalNumber(
-            0,
-            show_ellipsis=True,
-            num_decimal_places=3,
-            include_sign=True,
-        )
-        square = Square().to_edge(UP)
+        square = Square()
+        square.set_fill(BLUE_E, 1)
 
-        decimal.add_updater(lambda d: d.next_to(square, RIGHT))
-        decimal.add_updater(lambda d: d.set_value(square.get_center()[1]))
-        self.add(square, decimal)
+        # On all frames, the constructor Brace(square, UP) will
+        # be called, and the mobject brace will set its data to match
+        # that of the newly constructed object
+        brace = always_redraw(Brace, square, UP)
+
+        text, number = label = VGroup(
+            Text("Width = "),
+            DecimalNumber(
+                0,
+                show_ellipsis=True,
+                num_decimal_places=2,
+                include_sign=True,
+            )
+        )
+        label.arrange(RIGHT)
+
+        # This ensures that the method deicmal.next_to(square)
+        # is called on every frame
+        always(label.next_to, brace, UP)
+        # You could also write the following equivalent line
+        # label.add_updater(lambda m: m.next_to(brace, UP))
+
+        # If the argument itself might change, you can use f_always,
+        # for which the arguments following the initial Mobject method
+        # should be functions returning arguments to that method.
+        # The following line ensures thst decimal.set_value(square.get_y())
+        # is called every frame
+        f_always(number.set_value, square.get_width)
+        # You could also write the following equivalent line
+        # number.add_updater(lambda m: m.set_value(square.get_width()))
+
+        self.add(square, brace, label)
+
+        # Notice that the brace and label track with the square
         self.play(
-            square.to_edge, DOWN,
+            square.animate.scale(2),
             rate_func=there_and_back,
-            run_time=5,
+            run_time=2,
+        )
+        self.wait()
+        self.play(
+            square.animate.set_width(5, stretch=True),
+            run_time=3,
+        )
+        self.wait()
+        self.play(
+            square.animate.set_width(2),
+            run_time=3
         )
         self.wait()
 
-# See old_projects folder for many, many more
+        # In general, you can alway call Mobject.add_updater, and pass in
+        # a function that you want to be called on every frame.  The function
+        # should take in either one argument, the mobject, or two arguments,
+        # the mobject and the amount of time since the last frame.
+        now = self.time
+        w0 = square.get_width()
+        square.add_updater(
+            lambda m: m.set_width(w0 * math.sin(self.time - now) + w0)
+        )
+        self.wait(4 * PI)
+
+
+class CoordinateSystemExample(Scene):
+    def construct(self):
+        axes = Axes(
+            # x-axis ranges from -1 to 10, with a default step size of 1
+            x_range=(-1, 10),
+            # y-axis ranges from -2 to 2 with a step size of 0.5
+            y_range=(-2, 2, 0.5),
+            # The axes will be stretched so as to match the specified
+            # height and width
+            height=6,
+            width=10,
+            # Axes is made of two NumberLine mobjects.  You can specify
+            # their configuration with axis_config
+            axis_config={
+                "stroke_color": GREY_A,
+                "stroke_width": 2,
+            },
+            # Alternatively, you can specify configuration for just one
+            # of them, like this.
+            y_axis_config={
+                "include_tip": False,
+            }
+        )
+        # Keyword arguments of add_coordinate_labels can be used to
+        # configure the DecimalNumber mobjects which it creates and
+        # adds to the axes
+        axes.add_coordinate_labels(
+            font_size=20,
+            num_decimal_places=1,
+        )
+        self.add(axes)
+
+        # Axes descends from the CoordinateSystem class, meaning
+        # you can call call axes.coords_to_point, abbreviated to
+        # axes.c2p, to associate a set of coordinates with a point,
+        # like so:
+        dot = Dot(color=RED)
+        dot.move_to(axes.c2p(0, 0))
+        self.play(FadeIn(dot, scale=0.5))
+        self.play(dot.animate.move_to(axes.c2p(3, 2)))
+        self.wait()
+        self.play(dot.animate.move_to(axes.c2p(5, 0.5)))
+        self.wait()
+
+        # Similarly, you can call axes.point_to_coords, or axes.p2c
+        # print(axes.p2c(dot.get_center()))
+
+        # We can draw lines from the axes to better mark the coordinates
+        # of a given point.
+        # Here, the always_redraw command means that on each new frame
+        # the lines will be redrawn
+        h_line = always_redraw(lambda: axes.get_h_line(dot.get_left()))
+        v_line = always_redraw(lambda: axes.get_v_line(dot.get_bottom()))
+
+        self.play(
+            ShowCreation(h_line),
+            ShowCreation(v_line),
+        )
+        self.play(dot.animate.move_to(axes.c2p(3, -2)))
+        self.wait()
+        self.play(dot.animate.move_to(axes.c2p(1, 1)))
+        self.wait()
+
+        # If we tie the dot to a particular set of coordinates, notice
+        # that as we move the axes around it respects the coordinate
+        # system defined by them.
+        f_always(dot.move_to, lambda: axes.c2p(1, 1))
+        self.play(
+            axes.animate.scale(0.75).to_corner(UL),
+            run_time=2,
+        )
+        self.wait()
+        self.play(FadeOut(VGroup(axes, dot, h_line, v_line)))
+
+        # Other coordinate systems you can play around with include
+        # ThreeDAxes, NumberPlane, and ComplexPlane.
+
+
+class GraphExample(Scene):
+    def construct(self):
+        axes = Axes((-3, 10), (-1, 8))
+        axes.add_coordinate_labels()
+
+        self.play(Write(axes, lag_ratio=0.01, run_time=1))
+
+        # Axes.get_graph will return the graph of a function
+        sin_graph = axes.get_graph(
+            lambda x: 2 * math.sin(x),
+            color=BLUE,
+        )
+        # By default, it draws it so as to somewhat smoothly interpolate
+        # between sampled points (x, f(x)).  If the graph is meant to have
+        # a corner, though, you can set use_smoothing to False
+        relu_graph = axes.get_graph(
+            lambda x: max(x, 0),
+            use_smoothing=False,
+            color=YELLOW,
+        )
+        # For discontinuous functions, you can specify the point of
+        # discontinuity so that it does not try to draw over the gap.
+        step_graph = axes.get_graph(
+            lambda x: 2.0 if x > 3 else 1.0,
+            discontinuities=[3],
+            color=GREEN,
+        )
+
+        # Axes.get_graph_label takes in either a string or a mobject.
+        # If it's a string, it treats it as a LaTeX expression.  By default
+        # it places the label next to the graph near the right side, and
+        # has it match the color of the graph
+        sin_label = axes.get_graph_label(sin_graph, "\\sin(x)")
+        relu_label = axes.get_graph_label(relu_graph, Text("ReLU"))
+        step_label = axes.get_graph_label(step_graph, Text("Step"), x=4)
+
+        self.play(
+            ShowCreation(sin_graph),
+            FadeIn(sin_label, RIGHT),
+        )
+        self.wait(2)
+        self.play(
+            ReplacementTransform(sin_graph, relu_graph),
+            FadeTransform(sin_label, relu_label),
+        )
+        self.wait()
+        self.play(
+            ReplacementTransform(relu_graph, step_graph),
+            FadeTransform(relu_label, step_label),
+        )
+        self.wait()
+
+        parabola = axes.get_graph(lambda x: 0.25 * x**2)
+        parabola.set_stroke(BLUE)
+        self.play(
+            FadeOut(step_graph),
+            FadeOut(step_label),
+            ShowCreation(parabola)
+        )
+        self.wait()
+
+        # You can use axes.input_to_graph_point, abbreviated
+        # to axes.i2gp, to find a particular point on a graph
+        dot = Dot(color=RED)
+        dot.move_to(axes.i2gp(2, parabola))
+        self.play(FadeIn(dot, scale=0.5))
+
+        # A value tracker lets us animate a parameter, usually
+        # with the intent of having other mobjects update based
+        # on the parameter
+        x_tracker = ValueTracker(2)
+        f_always(
+            dot.move_to,
+            lambda: axes.i2gp(x_tracker.get_value(), parabola)
+        )
+
+        self.play(x_tracker.animate.set_value(4), run_time=3)
+        self.play(x_tracker.animate.set_value(-2), run_time=3)
+        self.wait()
+
+
+class SurfaceExample(Scene):
+    CONFIG = {
+        "camera_class": ThreeDCamera,
+    }
+
+    def construct(self):
+        surface_text = Text("For 3d scenes, try using surfaces")
+        surface_text.fix_in_frame()
+        surface_text.to_edge(UP)
+        self.add(surface_text)
+        self.wait(0.1)
+
+        torus1 = Torus(r1=1, r2=1)
+        torus2 = Torus(r1=3, r2=1)
+        sphere = Sphere(radius=3, resolution=torus1.resolution)
+        # You can texture a surface with up to two images, which will
+        # be interpreted as the side towards the light, and away from
+        # the light.  These can be either urls, or paths to a local file
+        # in whatever you've set as the image directory in
+        # the custom_config.yml file
+
+        # day_texture = "EarthTextureMap"
+        # night_texture = "NightEarthTextureMap"
+        day_texture = "https://upload.wikimedia.org/wikipedia/commons/thumb/4/4d/Whole_world_-_land_and_oceans.jpg/1280px-Whole_world_-_land_and_oceans.jpg"
+        night_texture = "https://upload.wikimedia.org/wikipedia/commons/thumb/b/ba/The_earth_at_night.jpg/1280px-The_earth_at_night.jpg"
+
+        surfaces = [
+            TexturedSurface(surface, day_texture, night_texture)
+            for surface in [sphere, torus1, torus2]
+        ]
+
+        for mob in surfaces:
+            mob.shift(IN)
+            mob.mesh = SurfaceMesh(mob)
+            mob.mesh.set_stroke(BLUE, 1, opacity=0.5)
+
+        # Set perspective
+        frame = self.camera.frame
+        frame.set_euler_angles(
+            theta=-30 * DEGREES,
+            phi=70 * DEGREES,
+        )
+
+        surface = surfaces[0]
+
+        self.play(
+            FadeIn(surface),
+            ShowCreation(surface.mesh, lag_ratio=0.01, run_time=3),
+        )
+        for mob in surfaces:
+            mob.add(mob.mesh)
+        surface.save_state()
+        self.play(Rotate(surface, PI / 2), run_time=2)
+        for mob in surfaces[1:]:
+            mob.rotate(PI / 2)
+
+        self.play(
+            Transform(surface, surfaces[1]),
+            run_time=3
+        )
+
+        self.play(
+            Transform(surface, surfaces[2]),
+            # Move camera frame during the transition
+            frame.animate.increment_phi(-10 * DEGREES),
+            frame.animate.increment_theta(-20 * DEGREES),
+            run_time=3
+        )
+        # Add ambient rotation
+        frame.add_updater(lambda m, dt: m.increment_theta(-0.1 * dt))
+
+        # Play around with where the light is
+        light_text = Text("You can move around the light source")
+        light_text.move_to(surface_text)
+        light_text.fix_in_frame()
+
+        self.play(FadeTransform(surface_text, light_text))
+        light = self.camera.light_source
+        self.add(light)
+        light.save_state()
+        self.play(light.animate.move_to(3 * IN), run_time=5)
+        self.play(light.animate.shift(10 * OUT), run_time=5)
+
+        drag_text = Text("Try moving the mouse while pressing d or s")
+        drag_text.move_to(light_text)
+        drag_text.fix_in_frame()
+
+        self.play(FadeTransform(light_text, drag_text))
+        self.wait()
+
+
+class InteractiveDevelopment(Scene):
+    def construct(self):
+        circle = Circle()
+        circle.set_fill(BLUE, opacity=0.5)
+        circle.set_stroke(BLUE_E, width=4)
+        square = Square()
+
+        self.play(ShowCreation(square))
+        self.wait()
+
+        # This opens an iPython termnial where you can keep writing
+        # lines as if they were part of this construct method.
+        # In particular, 'square', 'circle' and 'self' will all be
+        # part of the local namespace in that terminal.
+        self.embed()
+
+        # Try copying and pasting some of the lines below into
+        # the interactive shell
+        self.play(ReplacementTransform(square, circle))
+        self.wait()
+        self.play(circle.animate.stretch(4, 0))
+        self.play(Rotate(circle, 90 * DEGREES))
+        self.play(circle.animate.shift(2 * RIGHT).scale(0.25))
+
+        text = Text("""
+            In general, using the interactive shell
+            is very helpful when developing new scenes
+        """)
+        self.play(Write(text))
+
+        # In the interactive shell, you can just type
+        # play, add, remove, clear, wait, save_state and restore,
+        # instead of self.play, self.add, self.remove, etc.
+
+        # To interact with the window, type touch().  You can then
+        # scroll in the window, or zoom by holding down 'z' while scrolling,
+        # and change camera perspective by holding down 'd' while moving
+        # the mouse.  Press 'r' to reset to the standard camera position.
+        # Press 'q' to stop interacting with the window and go back to
+        # typing new commands into the shell.
+
+        # In principle you can customize a scene to be responsive to
+        # mouse and keyboard interactions
+        always(circle.move_to, self.mouse_point)
+
+
+class ControlsExample(Scene):
+    def setup(self):
+        self.textbox = Textbox()
+        self.checkbox = Checkbox()
+        self.color_picker = ColorSliders()
+        self.panel = ControlPanel(
+            Text("Text", font_size=24), self.textbox, Line(),
+            Text("Show/Hide Text", font_size=24), self.checkbox, Line(),
+            Text("Color of Text", font_size=24), self.color_picker
+        )
+        self.add(self.panel)
+
+    def construct(self):
+        text = Text("text", font_size=96)
+
+        def text_updater(old_text):
+            assert(isinstance(old_text, Text))
+            new_text = Text(self.textbox.get_value(), font_size=old_text.font_size)
+            # new_text.align_data_and_family(old_text)
+            new_text.move_to(old_text)
+            if self.checkbox.get_value():
+                new_text.set_fill(
+                    color=self.color_picker.get_picked_color(),
+                    opacity=self.color_picker.get_picked_opacity()
+                )
+            else:
+                new_text.set_opacity(0)
+            old_text.become(new_text)
+
+        text.add_updater(text_updater)
+
+        self.add(MotionMobject(text))
+
+        self.textbox.set_value("Manim")
+        # self.wait(60)
+        # self.embed()
+
+
+# See https://github.com/3b1b/videos for many, many more

from_3b1b/active/diffyq/all_part1_scenes.py

@@ -1,107 +0,0 @@
-from active_projects.diffyq.part1.pendulum import *
-from active_projects.diffyq.part1.staging import *
-from active_projects.diffyq.part1.pi_scenes import *
-from active_projects.diffyq.part1.phase_space import *
-from active_projects.diffyq.part1.wordy_scenes import *
-
-OUTPUT_DIRECTORY = "diffyq/part1"
-SCENES_IN_ORDER = [
-    WhenChangeIsEasier,
-    VectorFieldTest,
-    IntroducePendulum,
-    MultiplePendulumsOverlayed,
-    PeriodFormula,
-    FormulasAreLies,
-    MediumAnglePendulum,
-    MediumHighAnglePendulum,
-    HighAnglePendulum,
-    LowAnglePendulum,
-    SomeOfYouWatching,
-    SmallAngleApproximationTex,
-    VeryLowAnglePendulum,
-    FormulasAreLies,
-    TourOfDifferentialEquations,
-    WherePendulumLeads,
-    LongDoublePendulum,
-    # FollowThisThread,
-    StrogatzQuote,
-    ShowHorizontalDashedLine,
-    RabbitFoxPopulations,
-    RabbitFoxEquation,
-    # Something...
-    ShowSimpleTrajectory,
-    SimpleProjectileEquation,
-    SimpleProjectileEquationVGraphFreedom,
-    ShowGravityAcceleration,
-    UniversalGravityLawSymbols,
-    ExampleTypicalODE,
-    AnalyzePendulumForce,
-    ShowSineValues,
-    BuildUpEquation,
-    AirResistanceBrace,
-    ShowDerivativeVideo,
-    SubtleAirCurrents,
-    SimpleDampenedPendulum,
-    DefineODE,
-    SecondOrderEquationExample,
-    ODEvsPDEinFrames,
-    ProveTeacherWrong,
-    SetAsideSeekingSolution,
-    #
-    WriteInRadians,
-    XEqLThetaToCorner,
-    ComingUp,
-    InputLabel,
-    SoWhatIsThetaThen,
-    ReallyHardToSolve,
-    ReasonForSolution,
-    PhysicistPhaseSpace,
-    GleickQuote,
-    SpectrumOfStartingStates,
-    WritePhaseFlow,
-    AskAboutStability,
-    LoveExample,
-    PassageOfTime,
-    LovePhaseSpace,
-    ComparePhysicsToLove,
-    FramesComparingPhysicsToLove,
-    SetupToTakingManyTinySteps,
-    ShowClutterPrevention,
-    # VisualizeHeightSlopeCurvature,
-    VisualizeStates,
-    ReferencePiCollisionStateSpaces,
-    IntroduceVectorField,
-    XComponentArrows,
-    BreakingSecondOrderIntoTwoFirstOrder,
-    ShowPendulumPhaseFlow,
-    ShowHighVelocityCase,
-    TweakMuInFormula,
-    TweakMuInVectorField,
-    FromODEToVectorField,
-    LorenzVectorField,
-    ThreeBodiesInSpace,
-    AltThreeBodiesInSpace,
-    TwoBodiesInSpace,
-    TwoBodiesWithZPart,
-    ThreeBodyTitle,
-    ThreeBodySymbols,
-    #
-    HighAmplitudePendulum,
-    WritePhaseSpace,
-    #
-    AskAboutActuallySolving,
-    WriteODESolvingCode,
-    TakeManyTinySteps,
-    ManyStepsFromDifferentStartingPoints,
-    InaccurateComputation,
-    HungerForExactness,
-    ShowRect,
-    ShowSquare,
-    JumpToThisPoint,
-    ThreeBodyEquation,
-    ItGetsWorse,
-    ChaosTitle,
-    RevisitQuote,
-    EndScreen,
-    Thumbnail,
-]

from_3b1b/active/diffyq/all_part2_scenes.py

@@ -1,41 +0,0 @@
-from active_projects.diffyq.part2.staging import *
-from active_projects.diffyq.part2.fourier_series import *
-from active_projects.diffyq.part2.heat_equation import *
-from active_projects.diffyq.part2.pi_scenes import *
-from active_projects.diffyq.part2.wordy_scenes import *
-
-OUTPUT_DIRECTORY = "diffyq/part2"
-SCENES_IN_ORDER = [
-    PartTwoOfTour,
-    HeatEquationIntroTitle,
-    BrownianMotion,
-    BlackScholes,
-    ContrastChapters1And2,
-    FourierSeriesIntro,
-    FourierSeriesIntroBackground20,
-    ExplainCircleAnimations,
-    # FourierSeriesIntroBackground4,
-    # FourierSeriesIntroBackground8,
-    # FourierSeriesIntroBackground12,
-    TwoDBodyWithManyTemperatures,
-    TwoDBodyWithManyTemperaturesGraph,
-    TwoDBodyWithManyTemperaturesContour,
-    BringTwoRodsTogether,
-    ShowEvolvingTempGraphWithArrows,
-    # TodaysTargetWrapper,
-    WriteHeatEquation,
-    ReactionsToInitialHeatEquation,
-    TalkThrough1DHeatGraph,
-    ShowCubeFormation,
-    CompareInputsOfGeneralCaseTo1D,
-    ContrastXChangesToTChanges,
-    ShowPartialDerivativeSymbols,
-    WriteHeatEquation,
-    ShowCurvatureToRateOfChangeIntuition,
-    ContrastPDEToODE,
-    TransitionToTempVsTime,
-    Show1DAnd3DEquations,
-    #
-    AskAboutWhereEquationComesFrom,
-    DiscreteSetup,
-]

from_3b1b/active/diffyq/all_part3_scenes.py

@@ -1,70 +0,0 @@
-from active_projects.diffyq.part3.staging import *
-from active_projects.diffyq.part3.temperature_graphs import *
-from active_projects.diffyq.part3.pi_creature_scenes import *
-from active_projects.diffyq.part3.wordy_scenes import *
-from active_projects.diffyq.part3.discrete_case import *
-
-
-OUTPUT_DIRECTORY = "diffyq/part3"
-SCENES_IN_ORDER = [
-    LastChapterWrapper,
-    ThreeConstraints,
-    OceanOfPossibilities,
-    ThreeMainObservations,
-    SimpleCosExpGraph,
-    AddMultipleSolutions,
-    FourierSeriesIllustraiton,
-    BreakDownAFunction,
-    SineCurveIsUnrealistic,
-    AnalyzeSineCurve,
-    EquationAboveSineAnalysis,
-    ExponentialDecay,
-    InvestmentGrowth,
-    GrowingPileOfMoney,
-    CarbonDecayCurve,
-    CarbonDecayingInMammoth,
-    SineWaveScaledByExp,
-    ShowSinExpDerivatives,
-    IfOnly,
-    BoundaryConditionInterlude,
-    BoundaryConditionReference,
-    GiantCross,
-    SimulateRealSineCurve,
-    DerivativesOfLinearFunction,
-    StraightLine3DGraph,
-    SimulateLinearGraph,
-    EmphasizeBoundaryPoints,
-    ShowNewRuleAtDiscreteBoundary,
-    DiscreteEvolutionPoint25,
-    DiscreteEvolutionPoint1,
-    FlatEdgesForDiscreteEvolution,
-    FlatEdgesForDiscreteEvolutionTinySteps,
-    FlatEdgesContinuousEvolution,
-    FlatAtBoundaryWords,
-    SlopeToHeatFlow,
-    CloserLookAtStraightLine,
-    WriteOutBoundaryCondition,
-    SoWeGotNowhere,
-    ManipulateSinExpSurface,
-    HeatEquationFrame,
-    ShowFreq1CosExpDecay,
-    ShowFreq2CosExpDecay,
-    ShowFreq4CosExpDecay,
-    CompareFreqDecays1to2,
-    CompareFreqDecays1to4,
-    CompareFreqDecays2to4,
-    ShowHarmonics,
-    ShowHarmonicSurfaces,
-
-    # SimpleCosExpGraph,
-    # AddMultipleSolutions,
-    # IveHeardOfThis,
-    # FourierSeriesOfLineIllustration,
-    # InFouriersShoes,
-]
-
-PART_4_SCENES = [
-    FourierSeriesIllustraiton,
-    FourierNameIntro,
-    CircleAnimationOfF,
-]

from_3b1b/active/diffyq/all_part4_scenes.py

@@ -1,65 +0,0 @@
-from active_projects.diffyq.part4.staging import *
-from active_projects.diffyq.part4.fourier_series_scenes import *
-from active_projects.diffyq.part4.pi_creature_scenes import *
-from active_projects.diffyq.part4.three_d_graphs import *
-from active_projects.diffyq.part4.temperature_scenes import *
-from active_projects.diffyq.part4.complex_functions import *
-from active_projects.diffyq.part4.long_fourier_scenes import *
-
-from active_projects.diffyq.part3.staging import *
-
-OUTPUT_DIRECTORY = "diffyq/part4"
-SCENES_IN_ORDER = [
-    ComplexFourierSeriesExample,
-    FourierOfFourier,
-    FourierOfFourierZoomedIn,
-    FourierOfFourier100xZoom,
-    FourierSeriesFormula,
-    RelationToOtherVideos,
-    WhyWouldYouCare,
-    ShowLinearity,
-    CombineSeveralSolutions,
-    FourierGainsImmortality,
-    SolveForWavesNothingElse,
-    CycleThroughManyLinearCombinations,
-    StepFunctionExample,
-    WhichWavesAreAvailable,
-    AlternateBoundaryConditions,
-    AskQuestionOfGraph,
-    CommentOnFouriersImmortality,
-    HangOnThere,
-    ShowInfiniteSum,
-    TechnicalNuances,
-    BreakDownStepFunction,
-    StepFunctionSolutionFormla,
-    # How to compute
-    FourierSeriesOfLineIllustration,
-    GeneralizeToComplexFunctions,
-    ClarifyInputAndOutput,
-    GraphForFlattenedPi,
-    PiFourierSeries,
-    RealValuedFunctionFourierSeries,
-    YouSaidThisWasEasier,
-    AskAboutComplexNotVector,
-    SimpleComplexExponentExample,
-    LooseWithLanguage,
-    DemonstrateAddingArrows,
-    TRangingFrom0To1,
-    LabelRotatingVectors,
-    IntegralTrick,
-    SwapIntegralAndSum,
-    FootnoteOnSwappingIntegralAndSum,
-    FormulaOutOfContext,
-    ShowRangeOfCnFormulas,
-    DescribeSVG,
-    # TODO
-    IncreaseOrderOfApproximation,
-    ShowStepFunctionIn2dView,
-    StepFunctionIntegral,
-    GeneralChallenge,
-
-    # Oldies
-    # FourierSeriesIllustraiton,
-    # FourierNameIntro,
-    # CircleAnimationOfF,
-]

from_3b1b/active/diffyq/all_part5_scenes.py

@@ -1,5 +0,0 @@
-from active_projects.diffyq.part5.staging import *
-
-OUTPUT_DIRECTORY = "diffyq/part5"
-SCENES_IN_ORDER = [
-]

from_3b1b/active/diffyq/fourier_montage_scenes.py

@@ -1,23 +0,0 @@
-from active_projects.diffyq.part4.long_fourier_scenes import *
-
-OUTPUT_DIRECTORY = "diffyq/part4"
-SCENES_IN_ORDER = [
-    ZoomedInFourierSeriesExample,
-    FourierSeriesExampleWithRectForZoom,
-    ZoomedInFourierSeriesExample100x,
-    FourierOfFourier100xZoom,
-    FourierOfFourierZoomedIn,
-    FourierOfFourier,
-    SigmaZoomedInFourierSeriesExample,
-    SigmaFourierSeriesExampleWithRectForZoom,
-    NailAndGearZoomedInFourierSeriesExample,
-    NailAndGearFourierSeriesExampleWithRectForZoom,
-    TrebleClefZoomedInFourierSeriesExample,
-    TrebleClefFourierSeriesExampleWithRectForZoom,
-    FourierOfSeattle,
-    FourierOfSeattleZoomedIn,
-    FourierOfBritain,
-    FourierOfBritainZoomedIn,
-    FourierOfHilbert,
-    FourierOfHilbertZoomedIn,
-]

from_3b1b/active/diffyq/part1/pi_scenes.py

@@ -1,515 +0,0 @@
-from manimlib.imports import *
-from active_projects.diffyq.part1.shared_constructs import *
-
-
-class SomeOfYouWatching(TeacherStudentsScene):
-    CONFIG = {
-        "camera_config": {
-            "background_color": DARKER_GREY,
-        }
-    }
-
-    def construct(self):
-        screen = self.screen
-        screen.scale(1.25, about_edge=UL)
-        screen.set_fill(BLACK, 1)
-        self.add(screen)
-
-        self.teacher.change("raise_right_hand")
-        for student in self.students:
-            student.change("pondering", screen)
-
-        self.student_says(
-            "Well...yeah",
-            target_mode="tease"
-        )
-        self.wait(3)
-
-
-class FormulasAreLies(PiCreatureScene):
-    def construct(self):
-        you = self.pi_creature
-        t2c = {
-            "{L}": BLUE,
-            "{g}": YELLOW,
-            "\\theta_0": WHITE,
-            "\\sqrt{\\,": WHITE,
-        }
-        kwargs = {"tex_to_color_map": t2c}
-        period_eq = TexMobject(
-            "\\text{Period} = 2\\pi \\sqrt{\\,{L} / {g}}",
-            **kwargs
-        )
-        theta_eq = TexMobject(
-            "\\theta(t) = \\theta_0 \\cos\\left("
-            "\\sqrt{\\,{L} / {g}} \\cdot t"
-            "\\right)",
-            **kwargs
-        )
-        equations = VGroup(theta_eq, period_eq)
-        equations.arrange(DOWN, buff=LARGE_BUFF)
-
-        for eq in period_eq, theta_eq:
-            i = eq.index_of_part_by_tex("\\sqrt")
-            eq.sqrt_part = eq[i:i + 4]
-
-        theta0 = theta_eq.get_part_by_tex("\\theta_0")
-        theta0_words = TextMobject("Starting angle")
-        theta0_words.next_to(theta0, UL)
-        theta0_words.shift(UP + 0.5 * RIGHT)
-        arrow = Arrow(
-            theta0_words.get_bottom(),
-            theta0,
-            color=WHITE,
-            tip_length=0.25,
-        )
-
-        bubble = SpeechBubble()
-        bubble.pin_to(you)
-        bubble.write("Lies!")
-        bubble.content.scale(2)
-        bubble.resize_to_content()
-
-        self.add(period_eq)
-        you.change("pondering", period_eq)
-        self.wait()
-        theta_eq.remove(*theta_eq.sqrt_part)
-        self.play(
-            TransformFromCopy(
-                period_eq.sqrt_part,
-                theta_eq.sqrt_part,
-            ),
-            FadeIn(theta_eq)
-        )
-        theta_eq.add(*theta_eq.sqrt_part)
-        self.play(
-            FadeInFrom(theta0_words, LEFT),
-            GrowArrow(arrow),
-        )
-        self.wait()
-        self.play(you.change, "confused")
-        self.wait()
-        self.play(
-            you.change, "angry",
-            ShowCreation(bubble),
-            FadeInFromPoint(bubble.content, you.mouth),
-            equations.to_edge, LEFT,
-            FadeOut(arrow),
-            FadeOut(theta0_words),
-        )
-        self.wait()
-
-    def create_pi_creature(self):
-        return You().flip().to_corner(DR)
-
-
-# class TourOfDifferentialEquations(Scene):
-#     def construct(self):
-#         pass
-
-
-class SoWhatIsThetaThen(TeacherStudentsScene):
-    def construct(self):
-        ode = get_ode()
-        ode.to_corner(UL)
-        self.add(ode)
-
-        self.student_says(
-            "Okay, but then\\\\"
-            "what \\emph{is} $\\theta(t)$?"
-        )
-        self.wait()
-        self.play(self.teacher.change, "happy")
-        self.wait(2)
-        self.teacher_says(
-            "First, you must appreciate\\\\"
-            "a deep truth...",
-            added_anims=[self.get_student_changes(
-                *3 * ["confused"]
-            )]
-        )
-        self.wait(4)
-
-
-class ProveTeacherWrong(TeacherStudentsScene):
-    def construct(self):
-        tex_config = {
-            "tex_to_color_map": {
-                "{\\theta}": BLUE,
-                "{\\dot\\theta}": YELLOW,
-                "{\\ddot\\theta}": RED,
-            }
-        }
-        func = TexMobject(
-            "{\\theta}(t)", "=",
-            "\\theta_0", "\\cos(\\sqrt{g / L} \\cdot t)",
-            **tex_config,
-        )
-        d_func = TexMobject(
-            "{\\dot\\theta}(t)", "=",
-            "-\\left(\\sqrt{g / L}\\right)",
-            "\\theta_0", "\\sin(\\sqrt{g / L} \\cdot t)",
-            **tex_config,
-        )
-        dd_func = TexMobject(
-            "{\\ddot\\theta}(t)", "=",
-            "-\\left(g / L\\right)",
-            "\\theta_0", "\\cos(\\sqrt{g / L} \\cdot t)",
-            **tex_config,
-        )
-        # ode = TexMobject(
-        #     "\\ddot {\\theta}({t})", "=",
-        #     "-\\mu \\dot {\\theta}({t})",
-        #     "-{g \\over L} \\sin\\big({\\theta}({t})\\big)",
-        #     **tex_config,
-        # )
-        ode = get_ode()
-        arrows = [TexMobject("\\Downarrow") for x in range(2)]
-
-        VGroup(func, d_func, dd_func, ode, *arrows).scale(0.7)
-
-        teacher = self.teacher
-        you = self.students[2]
-
-        self.student_thinks(ode)
-        you.add_updater(lambda m: m.look_at(func))
-        self.teacher_holds_up(func)
-        self.wait()
-
-        group = VGroup(arrows[0], d_func, arrows[1], dd_func)
-        group.arrange(DOWN)
-        group.move_to(func, DOWN)
-
-        arrow = Arrow(
-            group.get_corner(UL),
-            ode.get_top(),
-            path_arc=PI / 2,
-        )
-        q_marks = VGroup(*[
-            TexMobject("?").scale(1.5).next_to(
-                arrow.point_from_proportion(a),
-                UP
-            )
-            for a in np.linspace(0.2, 0.8, 5)
-        ])
-        cycle_animation(VFadeInThenOut(
-            q_marks,
-            lag_ratio=0.2,
-            run_time=4,
-            rate_func=squish_rate_func(smooth, 0, 0.5)
-        ))
-
-        self.play(
-            func.next_to, group, UP,
-            LaggedStartMap(
-                FadeInFrom, group,
-                lambda m: (m, UP)
-            ),
-            teacher.change, "guilty",
-            you.change, "sassy",
-        )
-
-        rect = SurroundingRectangle(
-            VGroup(group, func)
-        )
-        dashed_rect = DashedVMobject(rect, num_dashes=75)
-        animated_rect = AnimatedBoundary(dashed_rect, cycle_rate=1)
-
-        self.wait()
-        self.add(animated_rect, q_marks)
-        self.play(
-            ShowCreation(arrow),
-            # FadeInFromDown(q_mark),
-            self.get_student_changes("confused", "confused")
-        )
-        self.wait(4)
-        self.change_student_modes(
-            *3 * ["pondering"],
-            self.teacher.change, "maybe"
-        )
-        self.wait(8)
-
-
-class PhysicistPhaseSpace(PiCreatureScene):
-    def construct(self):
-        physy = self.pi_creature
-        name = TextMobject("Physicist")
-        name.scale(1.5)
-        name.to_corner(DL, buff=MED_SMALL_BUFF)
-        physy.next_to(name, UP, SMALL_BUFF)
-        VGroup(name, physy).shift_onto_screen()
-
-        axes = Axes(
-            x_min=-1,
-            x_max=10,
-            y_min=-1,
-            y_max=7,
-        )
-        axes.set_height(6)
-        axes.next_to(physy, RIGHT)
-        axes.to_edge(UP)
-        axes.set_stroke(width=1)
-        x_label = TextMobject("Position")
-        x_label.next_to(axes.x_axis.get_right(), UP)
-        y_label = TextMobject("Momentum")
-        y_label.next_to(axes.y_axis.get_top(), RIGHT)
-
-        title = TextMobject("Phase space")
-        title.scale(1.5)
-        title.set_color(YELLOW)
-        title.move_to(axes)
-
-        self.add(name, physy)
-
-        self.play(
-            physy.change, "angry",
-            Write(axes),
-            FadeInFromDown(title)
-        )
-        self.wait(2)
-        self.play(
-            GrowFromPoint(x_label, physy.get_corner(UR)),
-            physy.change, "raise_right_hand",
-            axes.x_axis.get_right()
-        )
-        self.play(
-            GrowFromPoint(y_label, physy.get_corner(UR)),
-            physy.look_at, axes.y_axis.get_top(),
-        )
-        self.wait(3)
-
-    def create_pi_creature(self):
-        return PiCreature(color=GREY).to_corner(DL)
-
-
-class AskAboutActuallySolving(TeacherStudentsScene):
-    def construct(self):
-        ode = get_ode()
-        ode.to_corner(UL)
-        self.add(ode)
-        morty = self.teacher
-
-        self.student_says(
-            "Yeah yeah, but how do\\\\"
-            "you actually \\emph{solve} it?",
-            student_index=1,
-            target_mode="sassy",
-            added_anims=[morty.change, "thinking"],
-        )
-        self.change_student_modes(
-            "confused", "sassy", "confused",
-            look_at_arg=ode,
-        )
-        self.wait()
-        self.teacher_says(
-            "What do you mean\\\\ by ``solve''?",
-            target_mode="speaking",
-            added_anims=[self.get_student_changes(
-                *3 * ["erm"]
-            )]
-        )
-        self.play(self.students[1].change, "angry")
-        self.wait(3)
-
-
-class HungerForExactness(TeacherStudentsScene):
-    def construct(self):
-        students = self.students
-        you = students[2]
-        teacher = self.teacher
-
-        ode = get_ode()
-        ode.to_corner(UL)
-        left_part = ode[:5]
-        friction_part = ode[5:11]
-        self.add(ode)
-
-        proposed_solution = TexMobject(
-            "\\theta_0\\cos((\\sqrt{g/L})t)e^{-\\mu t}"
-        )
-        proposed_solution.next_to(
-            you.get_corner(UL), UP, buff=0.7
-        )
-        proposed_solution_rect = SurroundingRectangle(
-            proposed_solution, buff=MED_SMALL_BUFF,
-        )
-        proposed_solution_rect.set_color(BLUE)
-        proposed_solution_rect.round_corners()
-
-        solution_p1 = TexMobject(
-            """
-            \\theta(t) = 2\\text{am}\\left(
-                \\frac{\\sqrt{2g + Lc_1} (t + c_2)}{2\\sqrt{L}},
-                \\frac{4g}{2g + Lc_1}
-            \\right)
-            """,
-        )
-        solution_p1.to_corner(UL)
-        solution_p2 = TexMobject(
-            "c_1, c_2 = \\text{Constants depending on initial conditions}"
-        )
-        solution_p2.set_color(LIGHT_GREY)
-        solution_p2.scale(0.75)
-        solution_p3 = TexMobject(
-            """
-            \\text{am}(u, k) =
-            \\int_0^u \\text{dn}(v, k)\\,dv
-            """
-        )
-        solution_p3.name = TextMobject(
-            "(Jacobi amplitude function)"
-        )
-        solution_p4 = TexMobject(
-            """
-            \\text{dn}(u, k) =
-            \\sqrt{1 - k^2 \\sin^2(\\phi)}
-            """
-        )
-        solution_p4.name = TextMobject(
-            "(Jacobi elliptic function)"
-        )
-        solution_p5 = TextMobject("Where $\\phi$ satisfies")
-        solution_p6 = TexMobject(
-            """
-            u = \\int_0^\\phi \\frac{dt}{\\sqrt{1 - k^2 \\sin^2(t)}}
-            """
-        )
-
-        solution = VGroup(
-            solution_p1,
-            solution_p2,
-            solution_p3,
-            solution_p4,
-            solution_p5,
-            solution_p6,
-        )
-        solution.arrange(DOWN)
-        solution.scale(0.7)
-        solution.to_corner(UL, buff=MED_SMALL_BUFF)
-        solution.set_stroke(width=0, background=True)
-
-        solution.remove(solution_p2)
-        solution_p1.add(solution_p2)
-        solution.remove(solution_p5)
-        solution_p6.add(solution_p5)
-
-        for part in [solution_p3, solution_p4]:
-            part.name.scale(0.7 * 0.7)
-            part.name.set_color(LIGHT_GREY)
-            part.name.next_to(part, RIGHT)
-            part.add(part.name)
-
-        self.student_says(
-            "Right, but like,\\\\"
-            "what \\emph{is} $\\theta(t)$?",
-            target_mode="sassy",
-            added_anims=[teacher.change, "guilty"],
-        )
-        self.wait()
-        self.play(
-            FadeInFromDown(proposed_solution),
-            RemovePiCreatureBubble(
-                you,
-                target_mode="raise_left_hand",
-                look_at_arg=proposed_solution,
-            ),
-            teacher.change, "pondering",
-            students[0].change, "pondering",
-            students[1].change, "hesitant",
-        )
-        self.play(ShowCreation(proposed_solution_rect))
-        self.play(
-            proposed_solution.shift, 3 * RIGHT,
-            proposed_solution_rect.shift, 3 * RIGHT,
-            you.change, "raise_right_hand", teacher.eyes,
-        )
-        self.wait(3)
-
-        self.play(
-            FadeOut(proposed_solution),
-            FadeOut(proposed_solution_rect),
-            ode.move_to, self.hold_up_spot, DOWN,
-            ode.shift, LEFT,
-            teacher.change, "raise_right_hand",
-            self.get_student_changes(*3 * ["pondering"])
-        )
-        self.wait()
-        ode.save_state()
-        self.play(
-            left_part.move_to, friction_part, RIGHT,
-            left_part.match_y, left_part,
-            friction_part.to_corner, DR,
-            friction_part.fade, 0.5,
-        )
-        self.wait()
-
-        modes = ["erm", "sad", "sad", "horrified"]
-        for part, mode in zip(solution, modes):
-            self.play(
-                FadeInFrom(part, UP),
-                self.get_student_changes(
-                    *3 * [mode],
-                    look_at_arg=part,
-                )
-            )
-            self.wait()
-        self.wait(3)
-        self.change_student_modes("tired", "sad", "concerned_musician")
-        self.wait(4)
-        self.look_at(solution)
-        self.wait(5)
-        self.play(
-            FadeOutAndShift(solution, 2 * LEFT),
-            Restore(ode),
-            self.get_student_changes(
-                "sick", "angry", "tired",
-            )
-        )
-        self.wait(3)
-
-        mystery = TexMobject(
-            "\\theta(t) = ???",
-            tex_to_color_map={"\\theta": BLUE},
-        )
-        mystery.scale(2)
-        mystery.to_edge(UP)
-        mystery.set_stroke(width=0, background=True)
-        mystery_boundary = AnimatedBoundary(
-            mystery, stroke_width=1
-        )
-
-        self.play(
-            FadeInFromDown(mystery),
-            self.teacher.change, "pondering"
-        )
-        self.add(mystery_boundary, mystery)
-        self.change_all_student_modes("sad")
-        self.look_at(mystery)
-        self.wait(5)
-
-        # Define
-        self.student_says(
-            "Let $\\text{P}(\\mu, g, L; t)$ be a\\\\"
-            "function satisfying this ODE.",
-            student_index=0,
-            target_mode="speaking",
-            added_anims=[
-                FadeOut(mystery),
-                FadeOut(mystery_boundary),
-                ode.to_corner, UR
-            ]
-        )
-        self.change_student_modes(
-            "hooray", "sassy", "sassy",
-            look_at_arg=students[0].eyes.get_corner(UR),
-        )
-        self.wait(2)
-
-
-class ItGetsWorse(TeacherStudentsScene):
-    def construct(self):
-        self.teacher_says("It gets\\\\worse")
-        self.change_student_modes(
-            "hesitant", "pleading", "erm"
-        )
-        self.wait(5)

from_3b1b/active/diffyq/part1/shared_constructs.py

@@ -1,118 +0,0 @@
-from manimlib.imports import *
-
-
-Lg_formula_config = {
-    "tex_to_color_map": {
-        "\\theta_0": WHITE,
-        "{L}": BLUE,
-        "{g}": YELLOW,
-    },
-}
-
-
-class You(PiCreature):
-    CONFIG = {
-        "color": BLUE_C,
-    }
-
-
-def get_ode():
-    tex_config = {
-        "tex_to_color_map": {
-            "{\\theta}": BLUE,
-            "{\\dot\\theta}": RED,
-            "{\\ddot\\theta}": YELLOW,
-            "{t}": WHITE,
-            "{\\mu}": WHITE,
-        }
-    }
-    ode = TexMobject(
-        "{\\ddot\\theta}({t})", "=",
-        "-{\\mu} {\\dot\\theta}({t})",
-        "-{g \\over L} \\sin\\big({\\theta}({t})\\big)",
-        **tex_config,
-    )
-    return ode
-
-
-def get_period_formula():
-    return TexMobject(
-        "2\\pi", "\\sqrt{\\,", "L", "/", "g", "}",
-        tex_to_color_map={
-            "L": BLUE,
-            "g": YELLOW,
-        }
-    )
-
-
-def pendulum_vector_field_func(point, mu=0.1, g=9.8, L=3):
-    theta, omega = point[:2]
-    return np.array([
-        omega,
-        -np.sqrt(g / L) * np.sin(theta) - mu * omega,
-        0,
-    ])
-
-
-def get_vector_symbol(*texs, **kwargs):
-    config = {
-        "include_background_rectangle": True,
-        "bracket_h_buff": SMALL_BUFF,
-        "bracket_v_buff": SMALL_BUFF,
-        "element_alignment_corner": ORIGIN,
-    }
-    config.update(kwargs)
-    array = [[tex] for tex in texs]
-    return Matrix(array, **config)
-
-
-def get_heart_var(index):
-    heart = SuitSymbol("hearts")
-    if index == 1:
-        heart.set_color(BLUE_C)
-    elif index == 2:
-        heart.set_color(GREEN)
-    heart.set_height(0.7)
-    index = Integer(index)
-    index.move_to(heart.get_corner(DR))
-    heart.add(index)
-    return heart
-
-
-def get_heart_var_deriv(index):
-    heart = get_heart_var(index)
-    filler_tex = "T"
-    deriv = TexMobject("{d", filler_tex, "\\over", "dt}")
-    deriv.scale(2)
-    filler = deriv.get_part_by_tex(filler_tex)
-    heart.match_height(filler)
-    heart.move_to(filler)
-    heart.scale(1.5, about_edge=UL)
-    deriv.remove(filler)
-    deriv.add(heart)
-    deriv.heart = heart
-    return deriv
-
-
-def get_love_equation1():
-    equation = VGroup(
-        get_heart_var_deriv(1),
-        TexMobject("=").scale(2),
-        TexMobject("a").scale(2),
-        get_heart_var(2)
-    )
-    equation.arrange(RIGHT)
-    equation[-1].shift(SMALL_BUFF * DL)
-    return equation
-
-
-def get_love_equation2():
-    equation = VGroup(
-        get_heart_var_deriv(2),
-        TexMobject("=").scale(2),
-        TexMobject("-b").scale(2),
-        get_heart_var(1),
-    )
-    equation.arrange(RIGHT)
-    equation[-1].shift(SMALL_BUFF * DL)
-    return equation

from_3b1b/active/diffyq/part1/wordy_scenes.py

@@ -1,855 +0,0 @@
-from manimlib.imports import *
-from active_projects.diffyq.part1.shared_constructs import *
-
-
-class SmallAngleApproximationTex(Scene):
-    def construct(self):
-        approx = TexMobject(
-            "\\sin", "(", "\\theta", ") \\approx \\theta",
-            tex_to_color_map={"\\theta": RED},
-            arg_separator="",
-        )
-
-        implies = TexMobject("\\Downarrow")
-        period = TexMobject(
-            "\\text{Period}", "\\approx",
-            "2\\pi \\sqrt{\\,{L} / {g}}",
-            **Lg_formula_config,
-        )
-        group = VGroup(approx, implies, period)
-        group.arrange(DOWN)
-
-        approx_brace = Brace(approx, UP, buff=SMALL_BUFF)
-        approx_words = TextMobject(
-            "For small $\\theta$",
-            tex_to_color_map={"$\\theta$": RED},
-        )
-        approx_words.scale(0.75)
-        approx_words.next_to(approx_brace, UP, SMALL_BUFF)
-
-        self.add(approx, approx_brace, approx_words)
-        self.play(
-            Write(implies),
-            FadeInFrom(period, LEFT)
-        )
-        self.wait()
-
-
-class StrogatzQuote(Scene):
-    def construct(self):
-        quote = self.get_quote()
-        movers = VGroup(*quote[:-1].family_members_with_points())
-        for mover in movers:
-            mover.save_state()
-            disc = Circle(radius=0.05)
-            disc.set_stroke(width=0)
-            disc.set_fill(BLACK, 0)
-            disc.move_to(mover)
-            mover.become(disc)
-        self.play(
-            FadeInFrom(quote.author_part, LEFT),
-            LaggedStartMap(
-                # FadeInFromLarge,
-                # quote[:-1].family_members_with_points(),
-                Restore, movers,
-                lag_ratio=0.005,
-                run_time=2,
-            )
-            # FadeInFromDown(quote[:-1]),
-            # lag_ratio=0.01,
-        )
-        self.wait()
-        self.play(
-            Write(quote.law_part.copy().set_color(YELLOW)),
-            run_time=1,
-        )
-        self.wait()
-        self.play(
-            Write(quote.language_part.copy().set_color(BLUE)),
-            run_time=1.5,
-        )
-        self.wait(2)
-
-    def get_quote(self):
-        law_words = "laws of physics"
-        language_words = "language of differential equations"
-        author = "-Steven Strogatz"
-        quote = TextMobject(
-            """
-            \\Large
-            ``Since Newton, mankind has come to realize
-            that the laws of physics are always expressed
-            in the language of differential equations.''\\\\
-            """ + author,
-            alignment="",
-            arg_separator=" ",
-            substrings_to_isolate=[law_words, language_words, author]
-        )
-        quote.law_part = quote.get_part_by_tex(law_words)
-        quote.language_part = quote.get_part_by_tex(language_words)
-        quote.author_part = quote.get_part_by_tex(author)
-        quote.set_width(12)
-        quote.to_edge(UP)
-        quote[-2].shift(SMALL_BUFF * LEFT)
-        quote.author_part.shift(RIGHT + 0.5 * DOWN)
-        quote.author_part.scale(1.2, about_edge=UL)
-
-        return quote
-
-
-class WriteInRadians(Scene):
-    def construct(self):
-        words = TextMobject("In radians")
-        words.set_color(YELLOW)
-        square = SurroundingRectangle(TexMobject("\\theta"))
-        square.next_to(words, UP)
-        self.play(ShowCreation(square))
-        self.play(Write(words), FadeOut(square))
-        self.wait()
-
-
-class XEqLThetaToCorner(Scene):
-    def construct(self):
-        equation = TexMobject(
-            "x = L\\theta",
-            tex_to_color_map={
-                "x": GREEN,
-                "\\theta": BLUE,
-            }
-        )
-        equation.move_to(DOWN + 3 * RIGHT)
-        self.add(equation)
-        self.play(equation.to_corner, DL, {"buff": LARGE_BUFF})
-        self.wait()
-
-
-class ComingUp(Scene):
-    CONFIG = {
-        "camera_config": {"background_color": DARKER_GREY}
-    }
-
-    def construct(self):
-        frame = ScreenRectangle(
-            stroke_width=0,
-            fill_color=BLACK,
-            fill_opacity=1,
-            height=6
-        )
-        title = TextMobject("Coming up")
-        title.scale(1.5)
-        title.to_edge(UP)
-        frame.next_to(title, DOWN)
-        animated_frame = AnimatedBoundary(frame)
-        self.add(frame, title, animated_frame)
-        self.wait(10)
-
-
-class InputLabel(Scene):
-    def construct(self):
-        label = TextMobject("Input")
-        label.scale(1.25)
-        arrow = Vector(UP)
-        arrow.next_to(label, UP)
-        self.play(
-            FadeInFrom(label, UP),
-            GrowArrow(arrow)
-        )
-        self.wait()
-
-
-class ReallyHardToSolve(Scene):
-    def construct(self):
-        words = TextMobject(
-            "They're", "really\\\\",
-            "freaking", "hard\\\\",
-            "to", "solve\\\\",
-        )
-        words.set_height(6)
-
-        self.wait()
-        for word in words:
-            wait_time = 0.05 * len(word)
-            self.add(word)
-            self.wait(wait_time)
-        self.wait()
-
-
-class ReasonForSolution(Scene):
-    def construct(self):
-        # Words
-        eq_word = TextMobject("Differential\\\\Equation")
-        s_word = TextMobject("Solution")
-        u_word = TextMobject("Understanding")
-        c_word = TextMobject("Computation")
-        cu_group = VGroup(u_word, c_word)
-        cu_group.arrange(DOWN, buff=2)
-        group = VGroup(eq_word, s_word, cu_group)
-        group.arrange(RIGHT, buff=2)
-        # words = VGroup(eq_word, s_word, u_word, c_word)
-
-        # Arrows
-        arrows = VGroup(
-            Arrow(eq_word.get_right(), s_word.get_left()),
-            Arrow(s_word.get_right(), u_word.get_left()),
-            Arrow(s_word.get_right(), c_word.get_left()),
-        )
-        arrows.set_color(LIGHT_GREY)
-        new_arrows = VGroup(
-            Arrow(
-                eq_word.get_corner(UR),
-                u_word.get_left(),
-                path_arc=-60 * DEGREES,
-            ),
-            Arrow(
-                eq_word.get_corner(DR),
-                c_word.get_left(),
-                path_arc=60 * DEGREES,
-            ),
-        )
-        new_arrows.set_color(BLUE)
-
-        # Define first examples
-        t2c = {
-            "{x}": BLUE,
-            "{\\dot x}": RED,
-        }
-        equation = TexMobject(
-            "{\\dot x}(t) = k {x}(t)",
-            tex_to_color_map=t2c,
-        )
-        equation.next_to(eq_word, DOWN)
-        solution = TexMobject(
-            "{x}(t) = x_0 e^{kt}",
-            tex_to_color_map=t2c,
-        )
-        solution.next_to(s_word, DOWN, MED_LARGE_BUFF)
-        equation.align_to(solution, DOWN)
-
-        axes = Axes(
-            x_min=-1,
-            x_max=5.5,
-            y_min=-1,
-            y_max=4.5,
-            y_axis_config={"unit_size": 0.5}
-        )
-        axes.set_stroke(width=2)
-        graph_line = axes.get_graph(
-            lambda x: np.exp(0.4 * x)
-        )
-        graph_line.set_stroke(width=2)
-        graph = VGroup(axes, graph_line)
-        graph.scale(0.5)
-        graph.next_to(u_word, UP)
-
-        computation = TexMobject(
-            # "\\displaystyle "
-            "e^x = \\sum_{n=0}^\\infty "
-            "\\frac{x^n}{n!}"
-        )
-        computation.next_to(c_word, DOWN)
-
-        first_examples = VGroup(
-            equation, solution, graph, computation
-        )
-
-        # Second example
-        ode = get_ode()
-        ode.scale(0.75)
-        second_examples = VGroup(
-            ode,
-            TexMobject("???").set_color(LIGHT_GREY),
-            ScreenRectangle(
-                height=2,
-                stroke_width=1,
-            ),
-        )
-        for fe, se in zip(first_examples, second_examples):
-            se.move_to(fe, DOWN)
-
-        ode.shift(2 * SMALL_BUFF * DOWN)
-        ode.add_to_back(BackgroundRectangle(ode[-4:]))
-
-        self.add(eq_word)
-        self.add(equation)
-        self.play(
-            FadeInFrom(s_word, LEFT),
-            GrowArrow(arrows[0]),
-            TransformFromCopy(equation, solution)
-        )
-        self.wait()
-        self.play(
-            FadeInFrom(c_word, UL),
-            GrowArrow(arrows[2]),
-            FadeInFrom(computation, UP)
-        )
-        self.wait()
-        self.play(
-            FadeInFrom(u_word, DL),
-            GrowArrow(arrows[1]),
-            FadeInFromDown(graph)
-        )
-        self.wait(2)
-
-        self.play(
-            FadeOut(first_examples),
-            FadeIn(second_examples[:2])
-        )
-        self.wait()
-        self.play(
-            arrows.fade, 0.75,
-            s_word.fade, 0.75,
-            second_examples[1].fade, 0.75,
-            ShowCreation(new_arrows[0]),
-            FadeIn(second_examples[2])
-        )
-        self.play(
-            ShowCreation(new_arrows[1]),
-            Animation(second_examples),
-        )
-        self.wait()
-
-
-class WritePhaseSpace(Scene):
-    def construct(self):
-        word = TextMobject("Phase space")
-        word.scale(2)
-        word.shift(FRAME_WIDTH * LEFT / 4)
-        word.to_edge(UP)
-        word.add_background_rectangle()
-
-        lines = VGroup(*[
-            Line(v, 1.3 * v)
-            for v in compass_directions(50)
-        ])
-        lines.replace(word, stretch=True)
-        lines.scale(1.5)
-        lines.set_stroke(YELLOW)
-        lines.shuffle()
-
-        self.add(word)
-        self.play(
-            ShowPassingFlashWithThinningStrokeWidth(
-                lines,
-                lag_ratio=0.002,
-                run_time=1.5,
-                time_width=0.9,
-                n_segments=5,
-            )
-        )
-        self.wait()
-
-
-class GleickQuote(Scene):
-    def construct(self):
-        quote = TextMobject(
-            "``[Phase space is] one of the most\\\\",
-            "powerful inventions", "of modern science.''\\\\",
-        )
-        quote.power_part = quote.get_part_by_tex("power")
-        book = ImageMobject("ChaosBookCover")
-        book.set_height(5)
-        book.next_to(ORIGIN, LEFT)
-        book.to_edge(DOWN)
-        gleick = ImageMobject("JamesGleick")
-        gleick.set_height(5)
-        gleick.next_to(ORIGIN, RIGHT)
-        gleick.to_edge(DOWN)
-        quote.to_edge(UP)
-
-        self.play(
-            FadeInFrom(book, RIGHT),
-            FadeInFrom(gleick, LEFT),
-        )
-        self.wait()
-        self.play(Write(quote))
-        self.play(Write(
-            quote.power_part.copy().set_color(BLUE),
-            run_time=1
-        ))
-        self.wait()
-
-
-class WritePhaseFlow(Scene):
-    def construct(self):
-        words = TextMobject("Phase flow")
-        words.scale(2)
-        words.shift(FRAME_WIDTH * LEFT / 4)
-        words.to_edge(UP)
-        words.add_background_rectangle()
-        self.play(Write(words))
-        self.wait()
-
-
-class ShowSineValues(Scene):
-    def construct(self):
-        angle_tracker = ValueTracker(60 * DEGREES)
-        get_angle = angle_tracker.get_value
-        formula = always_redraw(
-            lambda: self.get_sine_formula(get_angle())
-        )
-        self.add(formula)
-
-        self.play(
-            angle_tracker.set_value, 0,
-            run_time=3,
-        )
-        self.wait()
-        self.play(
-            angle_tracker.set_value, 90 * DEGREES,
-            run_time=3,
-        )
-        self.wait()
-
-    def get_sine_formula(self, angle):
-        sin, lp, rp = TexMobject(
-            "\\sin", "(", ") = "
-        )
-        input_part = Integer(
-            angle / DEGREES,
-            unit="^\\circ",
-        )
-        input_part.set_color(YELLOW)
-        output_part = DecimalNumber(
-            np.sin(input_part.get_value() * DEGREES),
-            num_decimal_places=3,
-        )
-        result = VGroup(
-            sin, lp, input_part, rp, output_part
-        )
-        result.arrange(RIGHT, buff=SMALL_BUFF)
-        sin.scale(1.1, about_edge=DOWN)
-        lp.align_to(rp, UP)
-        return result
-
-
-class SetAsideSeekingSolution(Scene):
-    def construct(self):
-        ode = get_ode()
-        ode.to_edge(UP)
-        q1 = TextMobject("Find an exact solution")
-        q1.set_color(YELLOW)
-        q2 = TexMobject(
-            "\\text{What is }", "\\theta", "(t)",
-            "\\text{'s personality?}",
-            tex_to_color_map={"\\theta": BLUE},
-            arg_separator="",
-        )
-        theta = q2.get_part_by_tex("\\theta")
-
-        for q in q1, q2:
-            q.scale(1.5)
-            q.next_to(ode, DOWN, MED_LARGE_BUFF)
-        eyes = Eyes(theta, height=0.1)
-
-        self.add(ode)
-        self.add(q1)
-        self.wait()
-        self.play(
-            q1.scale, 0.3,
-            q1.to_corner, UR, MED_SMALL_BUFF,
-        )
-        self.play(FadeInFrom(q2, DOWN))
-        self.play(
-            eyes.blink,
-            rate_func=lambda t: smooth(1 - t),
-        )
-        self.play(eyes.look_at, q2.get_left())
-        self.play(eyes.look_at, q2.get_right())
-        self.play(
-            eyes.blink,
-            rate_func=squish_rate_func(there_and_back)
-        )
-        self.wait()
-        self.play(
-            eyes.change_mode, "confused",
-            eyes.look_at, ode.get_left(),
-        )
-        self.play(
-            eyes.blink,
-            rate_func=squish_rate_func(there_and_back)
-        )
-
-
-class ThreeBodyTitle(Scene):
-    def construct(self):
-        title = TextMobject("Three body problem")
-        title.scale(1.5)
-        title.to_edge(UP)
-        self.add(title)
-
-
-class ThreeBodySymbols(Scene):
-    def construct(self):
-        self.init_coord_groups()
-        self.introduce_coord_groups()
-        self.count_coords()
-
-    def init_coord_groups(self):
-        kwargs = {
-            "bracket_v_buff": 2 * SMALL_BUFF
-        }
-        positions = VGroup(*[
-            get_vector_symbol(*[
-                "{}_{}".format(s, i)
-                for s in "xyz"
-            ], **kwargs)
-            for i in range(1, 4)
-        ])
-        velocities = VGroup(*[
-            get_vector_symbol(*[
-                "p^{}_{}".format(s, i)
-                for s in "xyz"
-            ], **kwargs)
-            for i in range(1, 4)
-        ])
-        groups = VGroup(positions, velocities)
-        colors = [GREEN, RED, BLUE]
-        for group in groups:
-            for matrix in group:
-                matrix.coords = matrix.get_entries()
-                for coord, color in zip(matrix.coords, colors):
-                    coord.set_color(color)
-            group.arrange(RIGHT)
-        groups.arrange(DOWN, buff=LARGE_BUFF)
-        groups.to_edge(LEFT)
-
-        self.coord_groups = groups
-
-    def introduce_coord_groups(self):
-        groups = self.coord_groups
-        x_group, p_group = groups
-        x_word = TextMobject("Positions")
-        p_word = TextMobject("Momenta")
-        words = VGroup(x_word, p_word)
-        for word, group in zip(words, groups):
-            word.next_to(group, UP)
-
-        rect_groups = VGroup()
-        for group in groups:
-            rect_group = VGroup(*[
-                SurroundingRectangle(
-                    VGroup(*[
-                        tm.coords[i]
-                        for tm in group
-                    ]),
-                    color=WHITE,
-                    stroke_width=2,
-                )
-                for i in range(3)
-            ])
-            rect_groups.add(rect_group)
-
-        self.play(
-            *[
-                LaggedStartMap(
-                    FadeInFrom, group,
-                    lambda m: (m, UP),
-                    run_time=1,
-                )
-                for group in groups
-            ],
-            *map(FadeInFromDown, words),
-        )
-        for rect_group in rect_groups:
-            self.play(
-                ShowCreationThenFadeOut(
-                    rect_group,
-                    lag_ratio=0.5,
-                )
-            )
-        self.wait()
-
-    def count_coords(self):
-        coord_copies = VGroup()
-        for group in self.coord_groups:
-            for tex_mob in group:
-                for coord in tex_mob.coords:
-                    coord_copy = coord.copy()
-                    coord_copy.set_stroke(
-                        WHITE, 2, background=True
-                    )
-                    coord_copies.add(coord_copy)
-
-        count = Integer()
-        count_word = TextMobject("18", "degrees \\\\ of freedom")[1]
-        count_group = VGroup(count, count_word)
-        count_group.arrange(
-            RIGHT,
-            aligned_edge=DOWN,
-        )
-        count_group.scale(1.5)
-        count_group.next_to(
-            self.coord_groups, RIGHT,
-            aligned_edge=DOWN,
-        )
-        count.add_updater(
-            lambda m: m.set_value(len(coord_copies))
-        )
-        count.add_updater(
-            lambda m: m.next_to(count_word[0][0], LEFT, aligned_edge=DOWN)
-        )
-
-        self.add(count_group)
-        self.play(
-            # ChangeDecimalToValue(count, len(coord_copies)),
-            ShowIncreasingSubsets(coord_copies),
-            run_time=1.5,
-            rate_func=linear,
-        )
-        self.play(FadeOut(coord_copies))
-
-
-class ThreeBodyEquation(Scene):
-    def construct(self):
-        x1 = "\\vec{\\textbf{x}}_1"
-        x2 = "\\vec{\\textbf{x}}_2"
-        x3 = "\\vec{\\textbf{x}}_3"
-        kw = {
-            "tex_to_color_map": {
-                x1: RED,
-                x2: GREEN,
-                x3: BLUE,
-            }
-        }
-        equations = VGroup(*[
-            TexMobject(
-                "{d^2", t1, "\\over dt^2}", "=",
-                "G", "\\left("
-                "{" + m2, "(", t2, "-", t1, ")"
-                "\\over"
-                "||", t2, "-", t1, "||^3}",
-                "+",
-                "{" + m3, "(", t3, "-", t1, ")"
-                "\\over"
-                "||", t3, "-", t1, "||^3}",
-                "\\right)",
-                **kw
-            )
-            for t1, t2, t3, m1, m2, m3 in [
-                (x1, x2, x3, "m_1", "m_2", "m_3"),
-                (x2, x3, x1, "m_2", "m_3", "m_1"),
-                (x3, x1, x2, "m_3", "m_1", "m_2"),
-            ]
-        ])
-        equations.arrange(DOWN, buff=LARGE_BUFF)
-
-        self.play(LaggedStartMap(
-            FadeInFrom, equations,
-            lambda m: (m, UP),
-            lag_ratio=0.2,
-        ))
-        self.wait()
-
-
-class JumpToThisPoint(Scene):
-    def construct(self):
-        dot = Dot(color=YELLOW)
-        dot.scale(0.5)
-
-        arrow = Vector(DR, color=WHITE)
-        arrow.next_to(dot, UL, SMALL_BUFF)
-        words = TextMobject(
-            "Jump directly to\\\\",
-            "this point?",
-        )
-        words.add_background_rectangle_to_submobjects()
-        words.next_to(arrow.get_start(), UP, SMALL_BUFF)
-
-        self.play(
-            FadeInFromLarge(dot, 20),
-            rate_func=rush_into,
-        )
-        self.play(
-            GrowArrow(arrow),
-            FadeInFromDown(words),
-        )
-
-
-class ChaosTitle(Scene):
-    def construct(self):
-        title = TextMobject("Chaos theory")
-        title.scale(1.5)
-        title.to_edge(UP)
-        line = Line(LEFT, RIGHT)
-        line.set_width(FRAME_WIDTH - 1)
-        line.next_to(title, DOWN)
-
-        self.play(
-            Write(title),
-            ShowCreation(line),
-        )
-        self.wait()
-
-
-class RevisitQuote(StrogatzQuote, PiCreatureScene):
-    def construct(self):
-        quote = self.get_quote()
-        quote.law_part.set_color(YELLOW)
-        quote.language_part.set_color(BLUE)
-        quote.set_stroke(BLACK, 6, background=True)
-        quote.scale(0.8, about_edge=UL)
-
-        new_langauge_part = TextMobject(
-            "\\Large Language of differential equations"
-        )
-        new_langauge_part.to_edge(UP)
-        new_langauge_part.match_style(quote.language_part)
-
-        randy = self.pi_creature
-
-        self.play(
-            FadeInFrom(quote[:-1], DOWN),
-            FadeInFrom(quote[-1:], LEFT),
-            randy.change, "raise_right_hand",
-        )
-        self.play(Blink(randy))
-        self.play(randy.change, "angry")
-        self.play(
-            Blink(randy),
-            VFadeOut(randy, run_time=3)
-        )
-        mover = VGroup(quote.language_part)
-        self.add(quote, mover)
-        self.play(
-            ReplacementTransform(
-                mover, new_langauge_part,
-            ),
-            *[
-                FadeOut(part)
-                for part in quote
-                if part is not quote.language_part
-            ],
-            run_time=2,
-        )
-        self.wait()
-
-
-class EndScreen(PatreonEndScreen):
-    CONFIG = {
-        "specific_patrons": [
-            "Juan Benet",
-            "Vassili Philippov",
-            "Burt Humburg",
-            "Carlos Vergara Del Rio",
-            "Matt Russell",
-            "Scott Gray",
-            "soekul",
-            "Tihan Seale",
-            "Ali Yahya",
-            "dave nicponski",
-            "Evan Phillips",
-            "Graham",
-            "Joseph Kelly",
-            "Kaustuv DeBiswas",
-            "LambdaLabs",
-            "Lukas Biewald",
-            "Mike Coleman",
-            "Peter Mcinerney",
-            "Quantopian",
-            "Roy Larson",
-            "Scott Walter, Ph.D.",
-            "Yana Chernobilsky",
-            "Yu Jun",
-            "Jordan Scales",
-            "Lukas -krtek.net- Novy",
-            "John Shaughnessy",
-            "Britt Selvitelle",
-            "David Gow",
-            "J",
-            "Jonathan Wilson",
-            "Joseph John Cox",
-            "Magnus Dahlström",
-            "Randy C. Will",
-            "Ryan Atallah",
-            "Luc Ritchie",
-            "1stViewMaths",
-            "Adrian Robinson",
-            "Alexis Olson",
-            "Andreas Benjamin Brössel",
-            "Andrew Busey",
-            "Ankalagon",
-            "Antonio Juarez",
-            "Arjun Chakroborty",
-            "Art Ianuzzi",
-            "Awoo",
-            "Bernd Sing",
-            "Boris Veselinovich",
-            "Brian Staroselsky",
-            "Chad Hurst",
-            "Charles Southerland",
-            "Chris Connett",
-            "Christian Kaiser",
-            "Clark Gaebel",
-            "Cooper Jones",
-            "Danger Dai",
-            "Dave B",
-            "Dave Kester",
-            "David Clark",
-            "DeathByShrimp",
-            "Delton Ding",
-            "eaglle",
-            "emptymachine",
-            "Eric Younge",
-            "Eryq Ouithaqueue",
-            "Federico Lebron",
-            "Giovanni Filippi",
-            "Hal Hildebrand",
-            "Herman Dieset",
-            "Hitoshi Yamauchi",
-            "Isaac Jeffrey Lee",
-            "j eduardo perez",
-            "Jacob Magnuson",
-            "Jameel Syed",
-            "Jason Hise",
-            "Jeff Linse",
-            "Jeff Straathof",
-            "John Griffith",
-            "John Haley",
-            "John V Wertheim",
-            "Jonathan Eppele",
-            "Kai-Siang Ang",
-            "Kanan Gill",
-            "L0j1k",
-            "Lee Redden",
-            "Linh Tran",
-            "Ludwig Schubert",
-            "Magister Mugit",
-            "Mark B Bahu",
-            "Mark Heising",
-            "Martin Price",
-            "Mathias Jansson",
-            "Matt Langford",
-            "Matt Roveto",
-            "Matthew Cocke",
-            "Michael Faust",
-            "Michael Hardel",
-            "Mirik Gogri",
-            "Mustafa Mahdi",
-            "Márton Vaitkus",
-            "Nero Li",
-            "Nikita Lesnikov",
-            "Omar Zrien",
-            "Owen Campbell-Moore",
-            "Peter Ehrnstrom",
-            "RedAgent14",
-            "rehmi post",
-            "Richard Burgmann",
-            "Richard Comish",
-            "Ripta Pasay",
-            "Rish Kundalia",
-            "Robert Teed",
-            "Roobie",
-            "Ryan Williams",
-            "Samuel D. Judge",
-            "Solara570",
-            "Stevie Metke",
-            "Tal Einav",
-            "Ted Suzman",
-            "Valeriy Skobelev",
-            "Xavier Bernard",
-            "Yavor Ivanov",
-            "Yaw Etse",
-            "YinYangBalance.Asia",
-            "Zach Cardwell",
-        ]
-    }

from_3b1b/active/diffyq/part2/fourier_series.py

@@ -1,931 +0,0 @@
-from manimlib.imports import *
-# import scipy
-
-
-class FourierCirclesScene(Scene):
-    CONFIG = {
-        "n_vectors": 10,
-        "big_radius": 2,
-        "colors": [
-            BLUE_D,
-            BLUE_C,
-            BLUE_E,
-            GREY_BROWN,
-        ],
-        "circle_style": {
-            "stroke_width": 2,
-        },
-        "vector_config": {
-            "buff": 0,
-            "max_tip_length_to_length_ratio": 0.35,
-            "tip_length": 0.15,
-            "max_stroke_width_to_length_ratio": 10,
-            "stroke_width": 2,
-        },
-        "circle_config": {
-            "stroke_width": 1,
-        },
-        "base_frequency": 1,
-        "slow_factor": 0.25,
-        "center_point": ORIGIN,
-        "parametric_function_step_size": 0.001,
-        "drawn_path_color": YELLOW,
-        "drawn_path_stroke_width": 2,
-    }
-
-    def setup(self):
-        self.slow_factor_tracker = ValueTracker(
-            self.slow_factor
-        )
-        self.vector_clock = ValueTracker(0)
-        self.vector_clock.add_updater(
-            lambda m, dt: m.increment_value(
-                self.get_slow_factor() * dt
-            )
-        )
-        self.add(self.vector_clock)
-
-    def get_slow_factor(self):
-        return self.slow_factor_tracker.get_value()
-
-    def get_vector_time(self):
-        return self.vector_clock.get_value()
-
-    #
-    def get_freqs(self):
-        n = self.n_vectors
-        all_freqs = list(range(n // 2, -n // 2, -1))
-        all_freqs.sort(key=abs)
-        return all_freqs
-
-    def get_coefficients(self):
-        return [complex(0) for x in range(self.n_vectors)]
-
-    def get_color_iterator(self):
-        return it.cycle(self.colors)
-
-    def get_rotating_vectors(self, freqs=None, coefficients=None):
-        vectors = VGroup()
-        self.center_tracker = VectorizedPoint(self.center_point)
-
-        if freqs is None:
-            freqs = self.get_freqs()
-        if coefficients is None:
-            coefficients = self.get_coefficients()
-
-        last_vector = None
-        for freq, coefficient in zip(freqs, coefficients):
-            if last_vector:
-                center_func = last_vector.get_end
-            else:
-                center_func = self.center_tracker.get_location
-            vector = self.get_rotating_vector(
-                coefficient=coefficient,
-                freq=freq,
-                center_func=center_func,
-            )
-            vectors.add(vector)
-            last_vector = vector
-        return vectors
-
-    def get_rotating_vector(self, coefficient, freq, center_func):
-        vector = Vector(RIGHT, **self.vector_config)
-        vector.scale(abs(coefficient))
-        if abs(coefficient) == 0:
-            phase = 0
-        else:
-            phase = np.log(coefficient).imag
-        vector.rotate(phase, about_point=ORIGIN)
-        vector.freq = freq
-        vector.coefficient = coefficient
-        vector.center_func = center_func
-        vector.add_updater(self.update_vector)
-        return vector
-
-    def update_vector(self, vector, dt):
-        time = self.get_vector_time()
-        coef = vector.coefficient
-        freq = vector.freq
-        phase = np.log(coef).imag
-
-        vector.set_length(abs(coef))
-        vector.set_angle(phase + time * freq * TAU)
-        vector.shift(vector.center_func() - vector.get_start())
-        return vector
-
-    def get_circles(self, vectors):
-        return VGroup(*[
-            self.get_circle(
-                vector,
-                color=color
-            )
-            for vector, color in zip(
-                vectors,
-                self.get_color_iterator()
-            )
-        ])
-
-    def get_circle(self, vector, color=BLUE):
-        circle = Circle(color=color, **self.circle_config)
-        circle.center_func = vector.get_start
-        circle.radius_func = vector.get_length
-        circle.add_updater(self.update_circle)
-        return circle
-
-    def update_circle(self, circle):
-        circle.set_width(2 * circle.radius_func())
-        circle.move_to(circle.center_func())
-        return circle
-
-    def get_vector_sum_path(self, vectors, color=YELLOW):
-        coefs = [v.coefficient for v in vectors]
-        freqs = [v.freq for v in vectors]
-        center = vectors[0].get_start()
-
-        path = ParametricFunction(
-            lambda t: center + reduce(op.add, [
-                complex_to_R3(
-                    coef * np.exp(TAU * 1j * freq * t)
-                )
-                for coef, freq in zip(coefs, freqs)
-            ]),
-            t_min=0,
-            t_max=1,
-            color=color,
-            step_size=self.parametric_function_step_size,
-        )
-        return path
-
-    # TODO, this should be a general animated mobect
-    def get_drawn_path_alpha(self):
-        return self.get_vector_time()
-
-    def get_drawn_path(self, vectors, stroke_width=None, **kwargs):
-        if stroke_width is None:
-            stroke_width = self.drawn_path_stroke_width
-        path = self.get_vector_sum_path(vectors, **kwargs)
-        broken_path = CurvesAsSubmobjects(path)
-        broken_path.curr_time = 0
-
-        def update_path(path, dt):
-            # alpha = path.curr_time * self.get_slow_factor()
-            alpha = self.get_drawn_path_alpha()
-            n_curves = len(path)
-            for a, sp in zip(np.linspace(0, 1, n_curves), path):
-                b = alpha - a
-                if b < 0:
-                    width = 0
-                else:
-                    width = stroke_width * (1 - (b % 1))
-                sp.set_stroke(width=width)
-            path.curr_time += dt
-            return path
-
-        broken_path.set_color(self.drawn_path_color)
-        broken_path.add_updater(update_path)
-        return broken_path
-
-    def get_y_component_wave(self,
-                             vectors,
-                             left_x=1,
-                             color=PINK,
-                             n_copies=2,
-                             right_shift_rate=5):
-        path = self.get_vector_sum_path(vectors)
-        wave = ParametricFunction(
-            lambda t: op.add(
-                right_shift_rate * t * LEFT,
-                path.function(t)[1] * UP
-            ),
-            t_min=path.t_min,
-            t_max=path.t_max,
-            color=color,
-        )
-        wave_copies = VGroup(*[
-            wave.copy()
-            for x in range(n_copies)
-        ])
-        wave_copies.arrange(RIGHT, buff=0)
-        top_point = wave_copies.get_top()
-        wave.creation = ShowCreation(
-            wave,
-            run_time=(1 / self.get_slow_factor()),
-            rate_func=linear,
-        )
-        cycle_animation(wave.creation)
-        wave.add_updater(lambda m: m.shift(
-            (m.get_left()[0] - left_x) * LEFT
-        ))
-
-        def update_wave_copies(wcs):
-            index = int(
-                wave.creation.total_time * self.get_slow_factor()
-            )
-            wcs[:index].match_style(wave)
-            wcs[index:].set_stroke(width=0)
-            wcs.next_to(wave, RIGHT, buff=0)
-            wcs.align_to(top_point, UP)
-        wave_copies.add_updater(update_wave_copies)
-
-        return VGroup(wave, wave_copies)
-
-    def get_wave_y_line(self, vectors, wave):
-        return DashedLine(
-            vectors[-1].get_end(),
-            wave[0].get_end(),
-            stroke_width=1,
-            dash_length=DEFAULT_DASH_LENGTH * 0.5,
-        )
-
-    # Computing Fourier series
-    # i.e. where all the math happens
-    def get_coefficients_of_path(self, path, n_samples=10000, freqs=None):
-        if freqs is None:
-            freqs = self.get_freqs()
-        dt = 1 / n_samples
-        ts = np.arange(0, 1, dt)
-        samples = np.array([
-            path.point_from_proportion(t)
-            for t in ts
-        ])
-        samples -= self.center_point
-        complex_samples = samples[:, 0] + 1j * samples[:, 1]
-
-        result = []
-        for freq in freqs:
-            riemann_sum = np.array([
-                np.exp(-TAU * 1j * freq * t) * cs
-                for t, cs in zip(ts, complex_samples)
-            ]).sum() * dt
-            result.append(riemann_sum)
-
-        return result
-
-
-class FourierSeriesIntroBackground4(FourierCirclesScene):
-    CONFIG = {
-        "n_vectors": 4,
-        "center_point": 4 * LEFT,
-        "run_time": 30,
-        "big_radius": 1.5,
-    }
-
-    def construct(self):
-        circles = self.get_circles()
-        path = self.get_drawn_path(circles)
-        wave = self.get_y_component_wave(circles)
-        h_line = always_redraw(
-            lambda: self.get_wave_y_line(circles, wave)
-        )
-
-        # Why?
-        circles.update(-1 / self.camera.frame_rate)
-        #
-        self.add(circles, path, wave, h_line)
-        self.wait(self.run_time)
-
-    def get_ks(self):
-        return np.arange(1, 2 * self.n_vectors + 1, 2)
-
-    def get_freqs(self):
-        return self.base_frequency * self.get_ks()
-
-    def get_coefficients(self):
-        return self.big_radius / self.get_ks()
-
-
-class FourierSeriesIntroBackground8(FourierSeriesIntroBackground4):
-    CONFIG = {
-        "n_vectors": 8,
-    }
-
-
-class FourierSeriesIntroBackground12(FourierSeriesIntroBackground4):
-    CONFIG = {
-        "n_vectors": 12,
-    }
-
-
-class FourierSeriesIntroBackground20(FourierSeriesIntroBackground4):
-    CONFIG = {
-        "n_vectors": 20,
-    }
-
-
-class FourierOfPiSymbol(FourierCirclesScene):
-    CONFIG = {
-        "n_vectors": 51,
-        "center_point": ORIGIN,
-        "slow_factor": 0.1,
-        "n_cycles": 1,
-        "tex": "\\pi",
-        "start_drawn": False,
-        "max_circle_stroke_width": 1,
-    }
-
-    def construct(self):
-        self.add_vectors_circles_path()
-        for n in range(self.n_cycles):
-            self.run_one_cycle()
-
-    def add_vectors_circles_path(self):
-        path = self.get_path()
-        coefs = self.get_coefficients_of_path(path)
-        vectors = self.get_rotating_vectors(coefficients=coefs)
-        circles = self.get_circles(vectors)
-        self.set_decreasing_stroke_widths(circles)
-        # approx_path = self.get_vector_sum_path(circles)
-        drawn_path = self.get_drawn_path(vectors)
-        if self.start_drawn:
-            self.vector_clock.increment_value(1)
-
-        self.add(path)
-        self.add(vectors)
-        self.add(circles)
-        self.add(drawn_path)
-
-        self.vectors = vectors
-        self.circles = circles
-        self.path = path
-        self.drawn_path = drawn_path
-
-    def run_one_cycle(self):
-        time = 1 / self.slow_factor
-        self.wait(time)
-
-    def set_decreasing_stroke_widths(self, circles):
-        mcsw = self.max_circle_stroke_width
-        for k, circle in zip(it.count(1), circles):
-            circle.set_stroke(width=max(
-                # mcsw / np.sqrt(k),
-                mcsw / k,
-                mcsw,
-            ))
-        return circles
-
-    def get_path(self):
-        tex_mob = TexMobject(self.tex)
-        tex_mob.set_height(6)
-        path = tex_mob.family_members_with_points()[0]
-        path.set_fill(opacity=0)
-        path.set_stroke(WHITE, 1)
-        return path
-
-
-class FourierOfTexPaths(FourierOfPiSymbol, MovingCameraScene):
-    CONFIG = {
-        "n_vectors": 100,
-        "name_color": WHITE,
-        "animated_name": "Abc",
-        "time_per_symbol": 5,
-        "slow_factor": 1 / 5,
-        "parametric_function_step_size": 0.01,
-    }
-
-    def construct(self):
-        name = TextMobject(self.animated_name)
-        max_width = FRAME_WIDTH - 2
-        max_height = FRAME_HEIGHT - 2
-        name.set_width(max_width)
-        if name.get_height() > max_height:
-            name.set_height(max_height)
-
-        frame = self.camera.frame
-        frame.save_state()
-
-        vectors = VGroup(VectorizedPoint())
-        circles = VGroup(VectorizedPoint())
-        for path in name.family_members_with_points():
-            for subpath in path.get_subpaths():
-                sp_mob = VMobject()
-                sp_mob.set_points(subpath)
-                coefs = self.get_coefficients_of_path(sp_mob)
-                new_vectors = self.get_rotating_vectors(
-                    coefficients=coefs
-                )
-                new_circles = self.get_circles(new_vectors)
-                self.set_decreasing_stroke_widths(new_circles)
-
-                drawn_path = self.get_drawn_path(new_vectors)
-                drawn_path.clear_updaters()
-                drawn_path.set_stroke(self.name_color, 3)
-
-                static_vectors = VMobject().become(new_vectors)
-                static_circles = VMobject().become(new_circles)
-                # static_circles = new_circles.deepcopy()
-                # static_vectors.clear_updaters()
-                # static_circles.clear_updaters()
-
-                self.play(
-                    Transform(vectors, static_vectors, remover=True),
-                    Transform(circles, static_circles, remover=True),
-                    frame.set_height, 1.5 * name.get_height(),
-                    frame.move_to, path,
-                )
-
-                self.add(new_vectors, new_circles)
-                self.vector_clock.set_value(0)
-                self.play(
-                    ShowCreation(drawn_path),
-                    rate_func=linear,
-                    run_time=self.time_per_symbol
-                )
-                self.remove(new_vectors, new_circles)
-                self.add(static_vectors, static_circles)
-
-                vectors = static_vectors
-                circles = static_circles
-        self.play(
-            FadeOut(vectors),
-            Restore(frame),
-            run_time=2
-        )
-        self.wait(3)
-
-
-class FourierOfPiSymbol5(FourierOfPiSymbol):
-    CONFIG = {
-        "n_vectors": 5,
-        "run_time": 10,
-    }
-
-
-class FourierOfTrebleClef(FourierOfPiSymbol):
-    CONFIG = {
-        "n_vectors": 101,
-        "run_time": 10,
-        "start_drawn": True,
-        "file_name": "TrebleClef",
-        "height": 7.5,
-    }
-
-    def get_shape(self):
-        shape = SVGMobject(self.file_name)
-        return shape
-
-    def get_path(self):
-        shape = self.get_shape()
-        path = shape.family_members_with_points()[0]
-        path.set_height(self.height)
-        path.set_fill(opacity=0)
-        path.set_stroke(WHITE, 0)
-        return path
-
-
-class FourierOfIP(FourierOfTrebleClef):
-    CONFIG = {
-        "file_name": "IP_logo2",
-        "height": 6,
-        "n_vectors": 100,
-    }
-
-    # def construct(self):
-    #     path = self.get_path()
-    #     self.add(path)
-
-    def get_shape(self):
-        shape = SVGMobject(self.file_name)
-        return shape
-
-    def get_path(self):
-        shape = self.get_shape()
-        path = shape.family_members_with_points()[0]
-        path.add_line_to(path.get_start())
-        # path.make_smooth()
-
-        path.set_height(self.height)
-        path.set_fill(opacity=0)
-        path.set_stroke(WHITE, 0)
-        return path
-
-
-class FourierOfEighthNote(FourierOfTrebleClef):
-    CONFIG = {
-        "file_name": "EighthNote"
-    }
-
-
-class FourierOfN(FourierOfTrebleClef):
-    CONFIG = {
-        "height": 6,
-        "n_vectors": 1000,
-    }
-
-    def get_shape(self):
-        return TexMobject("N")
-
-
-class FourierNailAndGear(FourierOfTrebleClef):
-    CONFIG = {
-        "height": 6,
-        "n_vectors": 200,
-        "run_time": 100,
-        "slow_factor": 0.01,
-        "parametric_function_step_size": 0.0001,
-        "arrow_config": {
-            "tip_length": 0.1,
-            "stroke_width": 2,
-        }
-    }
-
-    def get_shape(self):
-        shape = SVGMobject("Nail_And_Gear")[1]
-        return shape
-
-
-class FourierBatman(FourierOfTrebleClef):
-    CONFIG = {
-        "height": 4,
-        "n_vectors": 100,
-        "run_time": 10,
-        "arrow_config": {
-            "tip_length": 0.1,
-            "stroke_width": 2,
-        }
-    }
-
-    def get_shape(self):
-        shape = SVGMobject("BatmanLogo")[1]
-        return shape
-
-
-class FourierHeart(FourierOfTrebleClef):
-    CONFIG = {
-        "height": 4,
-        "n_vectors": 100,
-        "run_time": 10,
-        "arrow_config": {
-            "tip_length": 0.1,
-            "stroke_width": 2,
-        }
-    }
-
-    def get_shape(self):
-        shape = SuitSymbol("hearts")
-        return shape
-
-    def get_drawn_path(self, *args, **kwargs):
-        kwargs["stroke_width"] = 5
-        path = super().get_drawn_path(*args, **kwargs)
-        path.set_color(PINK)
-        return path
-
-
-class FourierNDQ(FourierOfTrebleClef):
-    CONFIG = {
-        "height": 4,
-        "n_vectors": 1000,
-        "run_time": 10,
-        "arrow_config": {
-            "tip_length": 0.1,
-            "stroke_width": 2,
-        }
-    }
-
-    def get_shape(self):
-        path = VMobject()
-        shape = TexMobject("NDQ")
-        for sp in shape.family_members_with_points():
-            path.append_points(sp.points)
-        return path
-
-
-class FourierGoogleG(FourierOfTrebleClef):
-    CONFIG = {
-        "n_vectors": 10,
-        "height": 5,
-        "g_colors": [
-            "#4285F4",
-            "#DB4437",
-            "#F4B400",
-            "#0F9D58",
-        ]
-    }
-
-    def get_shape(self):
-        g = SVGMobject("google_logo")[5]
-        g.center()
-        self.add(g)
-        return g
-
-    def get_drawn_path(self, *args, **kwargs):
-        kwargs["stroke_width"] = 7
-        path = super().get_drawn_path(*args, **kwargs)
-
-        blue, red, yellow, green = self.g_colors
-
-        path[:250].set_color(blue)
-        path[250:333].set_color(green)
-        path[333:370].set_color(yellow)
-        path[370:755].set_color(red)
-        path[755:780].set_color(yellow)
-        path[780:860].set_color(green)
-        path[860:].set_color(blue)
-
-        return path
-
-
-class ExplainCircleAnimations(FourierCirclesScene):
-    CONFIG = {
-        "n_vectors": 100,
-        "center_point": 2 * DOWN,
-        "n_top_circles": 9,
-        "path_height": 3,
-    }
-
-    def construct(self):
-        self.add_path()
-        self.add_circles()
-        self.wait(8)
-        self.organize_circles_in_a_row()
-        self.show_frequencies()
-        self.show_examples_for_frequencies()
-        self.show_as_vectors()
-        self.show_vector_sum()
-        self.tweak_starting_vectors()
-
-    def add_path(self):
-        self.path = self.get_path()
-        self.add(self.path)
-
-    def add_circles(self):
-        coefs = self.get_coefficients_of_path(self.path)
-        self.circles = self.get_circles(coefficients=coefs)
-
-        self.add(self.circles)
-        self.drawn_path = self.get_drawn_path(self.circles)
-        self.add(self.drawn_path)
-
-    def organize_circles_in_a_row(self):
-        circles = self.circles
-        top_circles = circles[:self.n_top_circles].copy()
-
-        center_trackers = VGroup()
-        for circle in top_circles:
-            tracker = VectorizedPoint(circle.center_func())
-            circle.center_func = tracker.get_location
-            center_trackers.add(tracker)
-            tracker.freq = circle.freq
-            tracker.circle = circle
-
-        center_trackers.submobjects.sort(
-            key=lambda m: m.freq
-        )
-        center_trackers.generate_target()
-        right_buff = 1.45
-        center_trackers.target.arrange(RIGHT, buff=right_buff)
-        center_trackers.target.to_edge(UP, buff=1.25)
-
-        self.add(top_circles)
-        self.play(
-            MoveToTarget(center_trackers),
-            run_time=2
-        )
-        self.wait(4)
-
-        self.top_circles = top_circles
-        self.center_trackers = center_trackers
-
-    def show_frequencies(self):
-        center_trackers = self.center_trackers
-
-        freq_numbers = VGroup()
-        for ct in center_trackers:
-            number = Integer(ct.freq)
-            number.next_to(ct, DOWN, buff=1)
-            freq_numbers.add(number)
-            ct.circle.number = number
-
-        ld, rd = [
-            TexMobject("\\dots")
-            for x in range(2)
-        ]
-        ld.next_to(freq_numbers, LEFT, MED_LARGE_BUFF)
-        rd.next_to(freq_numbers, RIGHT, MED_LARGE_BUFF)
-        freq_numbers.add_to_back(ld)
-        freq_numbers.add(rd)
-
-        freq_word = TextMobject("Frequencies")
-        freq_word.scale(1.5)
-        freq_word.set_color(YELLOW)
-        freq_word.next_to(freq_numbers, DOWN, MED_LARGE_BUFF)
-
-        self.play(
-            LaggedStartMap(
-                FadeInFromDown, freq_numbers
-            )
-        )
-        self.play(
-            Write(freq_word),
-            LaggedStartMap(
-                ShowCreationThenFadeAround, freq_numbers,
-            )
-        )
-        self.wait(2)
-
-        self.freq_numbers = freq_numbers
-        self.freq_word = freq_word
-
-    def show_examples_for_frequencies(self):
-        top_circles = self.top_circles
-        c1, c2, c3 = [
-            list(filter(
-                lambda c: c.freq == k,
-                top_circles
-            ))[0]
-            for k in (1, 2, 3)
-        ]
-
-        neg_circles = VGroup(*filter(
-            lambda c: c.freq < 0,
-            top_circles
-        ))
-
-        for c in [c1, c2, c3, *neg_circles]:
-            c.rect = SurroundingRectangle(c)
-
-        self.play(
-            ShowCreation(c2.rect),
-            WiggleOutThenIn(c2.number),
-        )
-        self.wait(2)
-        self.play(
-            ReplacementTransform(c2.rect, c1.rect),
-        )
-        self.play(FadeOut(c1.rect))
-        self.wait()
-        self.play(
-            ShowCreation(c3.rect),
-            WiggleOutThenIn(c3.number),
-        )
-        self.play(
-            FadeOut(c3.rect),
-        )
-        self.wait(2)
-        self.play(
-            LaggedStart(*[
-                ShowCreationThenFadeOut(c.rect)
-                for c in neg_circles
-            ])
-        )
-        self.wait(3)
-        self.play(FadeOut(self.freq_word))
-
-    def show_as_vectors(self):
-        top_circles = self.top_circles
-        top_vectors = self.get_rotating_vectors(top_circles)
-        top_vectors.set_color(WHITE)
-
-        original_circles = top_circles.copy()
-        self.play(
-            FadeIn(top_vectors),
-            top_circles.set_opacity, 0,
-        )
-        self.wait(3)
-        self.play(
-            top_circles.match_style, original_circles
-        )
-        self.remove(top_vectors)
-
-        self.top_vectors = top_vectors
-
-    def show_vector_sum(self):
-        trackers = self.center_trackers.copy()
-        trackers.sort(
-            submob_func=lambda t: abs(t.circle.freq - 0.1)
-        )
-        plane = self.plane = NumberPlane(
-            x_min=-3,
-            x_max=3,
-            y_min=-2,
-            y_max=2,
-            axis_config={
-                "stroke_color": LIGHT_GREY,
-            }
-        )
-        plane.set_stroke(width=1)
-        plane.fade(0.5)
-        plane.move_to(self.center_point)
-
-        self.play(
-            FadeOut(self.drawn_path),
-            FadeOut(self.circles),
-            self.slow_factor_tracker.set_value, 0.05,
-        )
-        self.add(plane, self.path)
-        self.play(FadeIn(plane))
-
-        new_circles = VGroup()
-        last_tracker = None
-        for tracker in trackers:
-            if last_tracker:
-                tracker.new_location_func = last_tracker.circle.get_start
-            else:
-                tracker.new_location_func = lambda: self.center_point
-
-            original_circle = tracker.circle
-            tracker.circle = original_circle.copy()
-            tracker.circle.center_func = tracker.get_location
-            new_circles.add(tracker.circle)
-
-            self.add(tracker, tracker.circle)
-            start_point = tracker.get_location()
-            self.play(
-                UpdateFromAlphaFunc(
-                    tracker, lambda t, a: t.move_to(
-                        interpolate(
-                            start_point,
-                            tracker.new_location_func(),
-                            a,
-                        )
-                    ),
-                    run_time=2
-                )
-            )
-            tracker.add_updater(lambda t: t.move_to(
-                t.new_location_func()
-            ))
-            self.wait(2)
-            last_tracker = tracker
-
-        self.wait(3)
-
-        self.clear()
-        self.slow_factor_tracker.set_value(0.1)
-        self.add(
-            self.top_circles,
-            self.freq_numbers,
-            self.path,
-        )
-        self.add_circles()
-        for tc in self.top_circles:
-            for c in self.circles:
-                if c.freq == tc.freq:
-                    tc.rotate(
-                        angle_of_vector(c.get_start() - c.get_center()) -
-                        angle_of_vector(tc.get_start() - tc.get_center())
-                    )
-        self.wait(10)
-
-    def tweak_starting_vectors(self):
-        top_circles = self.top_circles
-        circles = self.circles
-        path = self.path
-        drawn_path = self.drawn_path
-
-        new_path = self.get_new_path()
-        new_coefs = self.get_coefficients_of_path(new_path)
-        new_circles = self.get_circles(coefficients=new_coefs)
-
-        new_top_circles = VGroup()
-        new_top_vectors = VGroup()
-        for top_circle in top_circles:
-            for circle in new_circles:
-                if circle.freq == top_circle.freq:
-                    new_top_circle = circle.copy()
-                    new_top_circle.center_func = top_circle.get_center
-                    new_top_vector = self.get_rotating_vector(
-                        new_top_circle
-                    )
-                    new_top_circles.add(new_top_circle)
-                    new_top_vectors.add(new_top_vector)
-
-        self.play(
-            self.slow_factor_tracker.set_value, 0,
-            FadeOut(drawn_path)
-        )
-        self.wait()
-        self.play(
-            ReplacementTransform(top_circles, new_top_circles),
-            ReplacementTransform(circles, new_circles),
-            FadeOut(path),
-            run_time=3,
-        )
-        new_drawn_path = self.get_drawn_path(
-            new_circles, stroke_width=4,
-        )
-        self.add(new_drawn_path)
-        self.slow_factor_tracker.set_value(0.1)
-        self.wait(20)
-
-    #
-    def configure_path(self, path):
-        path.set_stroke(WHITE, 1)
-        path.set_fill(BLACK, opacity=1)
-        path.set_height(self.path_height)
-        path.move_to(self.center_point)
-        return path
-
-    def get_path(self):
-        tex = TexMobject("f")
-        path = tex.family_members_with_points()[0]
-        self.configure_path(path)
-        return path
-        # return Square().set_height(3)
-
-    def get_new_path(self):
-        shape = SVGMobject("TrebleClef")
-        path = shape.family_members_with_points()[0]
-        self.configure_path(path)
-        path.scale(1.5, about_edge=DOWN)
-        return path

from_3b1b/active/diffyq/part2/pi_scenes.py

@@ -1,142 +0,0 @@
-from manimlib.imports import *
-from active_projects.diffyq.part2.wordy_scenes import WriteHeatEquationTemplate
-
-
-class ReactionsToInitialHeatEquation(PiCreatureScene):
-    def construct(self):
-        randy = self.pi_creature
-        randy.set_color(BLUE_C)
-        randy.center()
-
-        point = VectorizedPoint().next_to(randy, UL, LARGE_BUFF)
-        randy.add_updater(lambda r: r.look_at(point))
-
-        self.play(randy.change, "horrified")
-        self.wait()
-        self.play(randy.change, "pondering")
-        self.wait()
-        self.play(
-            randy.change, "confused",
-            point.next_to, randy, UR, LARGE_BUFF,
-        )
-        self.wait(2)
-        self.play(
-            point.shift, 2 * DOWN,
-            randy.change, "horrified"
-        )
-        self.wait(4)
-
-
-class ContrastPDEToODE(TeacherStudentsScene):
-    CONFIG = {
-        "random_seed": 2,
-    }
-
-    def construct(self):
-        student = self.students[2]
-        pde, ode = words = VGroup(*[
-            TextMobject(
-                text + "\\\\",
-                "Differential\\\\",
-                "Equation"
-            )
-            for text in ("Partial", "Ordinary")
-        ])
-        pde[0].set_color(YELLOW)
-        ode[0].set_color(BLUE)
-        for word in words:
-            word.arrange(DOWN, aligned_edge=LEFT)
-
-        words.arrange(RIGHT, buff=LARGE_BUFF)
-        words.next_to(student.get_corner(UR), UP, MED_LARGE_BUFF)
-        words.shift(UR)
-        lt = TexMobject("<")
-        lt.scale(1.5)
-        lt.move_to(Line(pde.get_right(), ode.get_left()))
-
-        for pi in self.pi_creatures:
-            pi.add_updater(lambda p: p.look_at(pde))
-
-        self.play(
-            FadeInFromDown(VGroup(words, lt)),
-            student.change, "raise_right_hand",
-        )
-        self.play(
-            self.get_student_changes("pondering", "pondering", "hooray"),
-            self.teacher.change, "happy"
-        )
-        self.wait(3)
-        self.play(
-            Swap(ode, pde),
-            self.teacher.change, "raise_right_hand",
-            self.get_student_changes(
-                "erm", "sassy", "confused"
-            )
-        )
-        self.look_at(words)
-        self.change_student_modes(
-            "thinking", "thinking", "tease",
-        )
-        self.wait(3)
-
-
-class AskAboutWhereEquationComesFrom(TeacherStudentsScene, WriteHeatEquationTemplate):
-    def construct(self):
-        equation = self.get_d1_equation()
-        equation.move_to(self.hold_up_spot, DOWN)
-
-        self.play(
-            FadeInFromDown(equation),
-            self.teacher.change, "raise_right_hand"
-        )
-        self.student_says(
-            "Um...why?",
-            target_mode="sassy",
-            student_index=2,
-            bubble_kwargs={"direction": RIGHT},
-        )
-        self.change_student_modes(
-            "confused", "confused", "sassy",
-        )
-        self.wait()
-        self.play(
-            self.teacher.change, "pondering",
-        )
-        self.wait(2)
-
-
-class AskWhyRewriteIt(TeacherStudentsScene):
-    def construct(self):
-        self.student_says(
-            "Why?", student_index=1,
-            bubble_kwargs={"height": 2, "width": 2},
-        )
-        self.students[1].bubble = None
-        self.teacher_says(
-            "One step closer\\\\to derivatives"
-        )
-        self.change_student_modes(
-            "thinking", "thinking", "thinking",
-            look_at_arg=4 * LEFT + 2 * UP
-        )
-        self.wait(2)
-
-
-class ReferenceKhanVideo(TeacherStudentsScene):
-    def construct(self):
-        khan_logo = ImageMobject("KhanLogo")
-        khan_logo.set_height(1)
-        khan_logo.next_to(self.teacher, UP, buff=2)
-        khan_logo.shift(2 * LEFT)
-
-        self.play(
-            self.teacher.change, "raise_right_hand",
-        )
-        self.change_student_modes(
-            "thinking", "pondering", "thinking",
-            look_at_arg=self.screen
-        )
-        self.wait()
-        self.play(FadeInFromDown(khan_logo))
-        self.look_at(self.screen)
-        self.wait(15)

from_3b1b/active/diffyq/part2/shared_constructs.py

@@ -1,35 +0,0 @@
-from manimlib.imports import *
-
-TIME_COLOR = YELLOW
-X_COLOR = GREEN
-
-
-def get_heat_equation():
-    pass
-
-
-def temperature_to_color(temp, min_temp=-1, max_temp=1):
-    colors = [BLUE, TEAL, GREEN, YELLOW, "#ff0000"]
-
-    alpha = inverse_interpolate(min_temp, max_temp, temp)
-    index, sub_alpha = integer_interpolate(
-        0, len(colors) - 1, alpha
-    )
-    return interpolate_color(
-        colors[index], colors[index + 1], sub_alpha
-    )
-
-
-def two_d_temp_func(x, y, t):
-    return np.sum([
-        c * np.sin(f * var) * np.exp(-(f**2) * t)
-        for c, f, var in [
-            (0.2, 1, x),
-            (0.3, 3, x),
-            (0.02, 5, x),
-            (0.01, 7, x),
-            (0.5, 2, y),
-            (0.1, 10, y),
-            (0.01, 20, y),
-        ]
-    ])

from_3b1b/active/diffyq/part2/staging.py

@@ -1,794 +0,0 @@
-from manimlib.imports import *
-from active_projects.diffyq.part1.staging import TourOfDifferentialEquations
-
-
-class PartTwoOfTour(TourOfDifferentialEquations):
-    CONFIG = {
-        "zoomed_thumbnail_index": 1,
-    }
-
-    def construct(self):
-        self.add_title()
-        self.show_thumbnails()
-        self.zoom_in_to_one_thumbnail()
-
-    def zoom_in_to_one_thumbnail(self):
-        frame = self.camera_frame
-        thumbnails = self.thumbnails
-
-        ode = TextMobject("Ordinary\\\\", "Differential Equation")
-        pde = TextMobject("Partial\\\\", "Differential Equation")
-        for word, thumbnail, vect in zip([ode, pde], thumbnails, [DOWN, UP]):
-            word.match_width(thumbnail)
-            word.next_to(thumbnail, vect)
-        ode[0].set_color(BLUE)
-        pde[0].set_color(YELLOW)
-
-        self.add(ode)
-
-        frame.save_state()
-        self.play(
-            frame.replace,
-            thumbnails[0],
-            run_time=1,
-        )
-        self.play(
-            Restore(frame, run_time=3),
-        )
-        self.play(
-            TransformFromCopy(ode, pde),
-        )
-        self.play(
-            ApplyMethod(
-                frame.replace, thumbnails[1],
-                path_arc=(-30 * DEGREES),
-                run_time=3
-            ),
-        )
-        self.wait()
-
-
-class BrownianMotion(Scene):
-    CONFIG = {
-        "wait_time": 60,
-        "L": 3,  # Box in [-L, L] x [-L, L]
-        "n_particles": 100,
-        "m1": 1,
-        "m2": 100,
-        "r1": 0.05,
-        "r2": 0.5,
-        "max_v": 5,
-        "random_seed": 2,
-    }
-
-    def construct(self):
-        self.add_title()
-        self.add_particles()
-        self.wait(self.wait_time)
-
-    def add_title(self):
-        square = Square(side_length=2 * self.L)
-        title = TextMobject("Brownian motion")
-        title.scale(1.5)
-        title.next_to(square, UP)
-
-        self.add(square)
-        self.add(title)
-
-    def add_particles(self):
-        m1 = self.m1
-        m2 = self.m2
-        r1 = self.r1
-        r2 = self.r2
-        L = self.L
-        max_v = self.max_v
-        n_particles = self.n_particles
-
-        lil_particles = VGroup(*[
-            self.get_particle(m1, r1, L, max_v)
-            for k in range(n_particles)
-        ])
-        big_particle = self.get_particle(m2, r2, L=r2, max_v=0)
-        big_particle.set_fill(YELLOW, 1)
-
-        for p in lil_particles:
-            if self.are_colliding(p, big_particle):
-                lil_particles.remove(p)
-        all_particles = VGroup(big_particle, *lil_particles)
-        all_particles.add_updater(self.update_particles)
-
-        path = self.get_traced_path(big_particle)
-
-        self.add(all_particles)
-        self.add(path)
-
-        self.particles = all_particles
-        self.big_particle = big_particle
-        self.path = path
-
-    def get_particle(self, m, r, L, max_v):
-        dot = Dot(radius=r)
-        dot.set_fill(WHITE, 0.7)
-        dot.mass = m
-        dot.radius = r
-        dot.center = op.add(
-            np.random.uniform(-L + r, L - r) * RIGHT,
-            np.random.uniform(-L + r, L - r) * UP
-        )
-        dot.move_to(dot.center)
-        dot.velocity = rotate_vector(
-            np.random.uniform(0, max_v) * RIGHT,
-            np.random.uniform(0, TAU),
-        )
-        return dot
-
-    def are_colliding(self, p1, p2):
-        d = get_norm(p1.get_center() - p2.get_center())
-        return (d < p1.radius + p2.radius)
-
-    def get_traced_path(self, particle):
-        path = VMobject()
-        path.set_stroke(BLUE, 3)
-        path.start_new_path(particle.get_center())
-
-        buff = 0.02
-
-        def update_path(path):
-            new_point = particle.get_center()
-            if get_norm(new_point - path.get_last_point()) > buff:
-                path.add_line_to(new_point)
-
-        path.add_updater(update_path)
-        return path
-
-    def update_particles(self, particles, dt):
-        for p1 in particles:
-            p1.center += p1.velocity * dt
-
-            # Check particle collisions
-            buff = 0.01
-            for p2 in particles:
-                if p1 is p2:
-                    continue
-                v = p2.center - p1.center
-                dist = get_norm(v)
-                r_sum = p1.radius + p2.radius
-                diff = dist - r_sum
-                if diff < 0:
-                    unit_v = v / dist
-                    p1.center += (diff - buff) * unit_v / 2
-                    p2.center += -(diff - buff) * unit_v / 2
-                    u1 = p1.velocity
-                    u2 = p2.velocity
-                    m1 = p1.mass
-                    m2 = p2.mass
-                    v1 = (
-                        (m2 * (u2 - u1) + m1 * u1 + m2 * u2) /
-                        (m1 + m2)
-                    )
-                    v2 = (
-                        (m1 * (u1 - u2) + m1 * u1 + m2 * u2) /
-                        (m1 + m2)
-                    )
-                    p1.velocity = v1
-                    p2.velocity = v2
-
-            # Check edge collisions
-            r1 = p1.radius
-            c1 = p1.center
-            for i in [0, 1]:
-                if abs(c1[i]) + r1 > self.L:
-                    c1[i] = np.sign(c1[i]) * (self.L - r1)
-                    p1.velocity[i] *= -1 * op.mul(
-                        np.sign(p1.velocity[i]),
-                        np.sign(c1[i])
-                    )
-
-        for p in particles:
-            p.move_to(p.center)
-        return particles
-
-
-class AltBrownianMotion(BrownianMotion):
-    CONFIG = {
-        "wait_time": 20,
-        "n_particles": 100,
-        "m2": 10,
-    }
-
-
-class BlackScholes(AltBrownianMotion):
-    def construct(self):
-        # For some reason I'm amused by the thought
-        # Of this graph perfectly matching the Brownian
-        # Motion y-coordiante
-        self.add_title()
-        self.add_particles()
-        self.particles.set_opacity(0)
-        self.remove(self.path)
-        self.add_graph()
-        self.wait(self.wait_time)
-
-    def add_title(self):
-        title = TextMobject("Black-Scholes equations")
-        title.scale(1.5)
-        title.next_to(2 * UP, UP)
-
-        equation = TexMobject(
-            "{\\partial V \\over \\partial t}", "+",
-            "\\frac{1}{2} \\sigma^2 S^2",
-            "{\\partial^2 V \\over \\partial S^2}", "+",
-            "rS", "{\\partial V \\over \\partial S}",
-            "-rV", "=", "0",
-        )
-        equation.scale(0.8)
-        equation.next_to(title, DOWN)
-
-        self.add(title)
-        self.add(equation)
-        self.title = title
-        self.equation = equation
-
-    def add_graph(self):
-        axes = Axes(
-            x_min=-1,
-            x_max=20,
-            y_min=0,
-            y_max=10,
-            axis_config={
-                "unit_size": 0.5,
-            },
-        )
-        axes.set_height(4)
-        axes.move_to(DOWN)
-
-        def get_graph_point():
-            return axes.c2p(
-                self.get_time(),
-                5 + 2 * self.big_particle.get_center()[1]
-            )
-
-        graph = VMobject()
-        graph.match_style(self.path)
-        graph.start_new_path(get_graph_point())
-        graph.add_updater(
-            lambda g: g.add_line_to(get_graph_point())
-        )
-
-        self.add(axes)
-        self.add(graph)
-
-
-class ContrastChapters1And2(Scene):
-    def construct(self):
-        c1_frame, c2_frame = frames = VGroup(*[
-            ScreenRectangle(height=3.5)
-            for x in range(2)
-        ])
-        frames.arrange(RIGHT, buff=LARGE_BUFF)
-
-        c1_title, c2_title = titles = VGroup(
-            TextMobject("Chapter 1"),
-            TextMobject("Chapter 2"),
-        )
-        titles.scale(1.5)
-
-        ode, pde = des = VGroup(
-            TextMobject(
-                "Ordinary",
-                "Differential Equations\\\\",
-                "ODEs",
-            ),
-            TextMobject(
-                "Partial",
-                "Differential Equations\\\\",
-                "PDEs",
-            ),
-        )
-        ode[0].set_color(BLUE)
-        pde[0].set_color(YELLOW)
-        for de in des:
-            de[-1][0].match_color(de[0])
-            de[-1].scale(1.5, about_point=de.get_top())
-
-        for title, frame, de in zip(titles, frames, des):
-            title.next_to(frame, UP)
-            de.match_width(frame)
-            de.next_to(frame, DOWN)
-
-        lt = TexMobject("<")
-        lt.move_to(Line(ode.get_right(), pde.get_left()))
-        lt.scale(2, about_edge=UP)
-
-        c1_words = TextMobject(
-            "They're", "really\\\\", "{}",
-            "freaking", "hard\\\\",
-            "to", "solve\\\\",
-        )
-        c1_words.set_height(0.5 * c1_frame.get_height())
-        c1_words.move_to(c1_frame)
-
-        c2_words = TextMobject(
-            "They're", "really", "\\emph{really}\\\\",
-            "freaking", "hard\\\\",
-            "to", "solve\\\\",
-        )
-        c2_words.set_color_by_tex("\\emph", YELLOW)
-        c2_words.move_to(c2_frame)
-        edit_shift = MED_LARGE_BUFF * RIGHT
-        c2_edits = VGroup(
-            TextMobject("sometimes").next_to(
-                c2_words[1:3], UP,
-                aligned_edge=LEFT,
-            ),
-            Line(
-                c2_words[1].get_left(),
-                c2_words[2].get_right(),
-                stroke_width=8,
-            ),
-            TextMobject("not too").next_to(
-                c2_words[3], LEFT,
-            ),
-            Line(
-                c2_words[3].get_left(),
-                c2_words[3].get_right(),
-                stroke_width=8,
-            ),
-        )
-        c2_edits.set_color(RED)
-        c2_edits[2:].shift(edit_shift)
-
-        self.add(titles)
-        self.add(frames)
-        self.add(des)
-
-        self.wait()
-        self.play(LaggedStartMap(
-            FadeInFromDown, c1_words,
-            lag_ratio=0.1,
-        ))
-        self.wait()
-        # self.play(FadeIn(ode))
-        self.play(
-            # TransformFromCopy(ode, pde),
-            TransformFromCopy(c1_words, c2_words),
-            Write(lt)
-        )
-        self.wait()
-        self.play(
-            Write(c2_edits[:2], run_time=1),
-        )
-        self.play(
-            c2_words[3:5].shift, edit_shift,
-            Write(c2_edits[2:]),
-            run_time=1,
-        )
-        self.wait()
-
-
-class ShowCubeFormation(ThreeDScene):
-    CONFIG = {
-        "camera_config": {
-            "shading_factor": 1.0,
-        },
-        "color": False,
-    }
-
-    def construct(self):
-        light_source = self.camera.light_source
-        light_source.move_to(np.array([-6, -3, 6]))
-
-        cube = Cube(
-            side_length=4,
-            fill_color=GREY,
-            stroke_color=WHITE,
-            stroke_width=0.5,
-        )
-        cube.set_fill(opacity=1)
-        if self.color:
-            # cube[0].set_color(BLUE)
-            # cube[1].set_color(RED)
-            # for face in cube[2:]:
-            #     face.set_color([BLUE, RED])
-            cube.color_using_background_image("VerticalTempGradient")
-
-        # light_source.next_to(cube, np.array([1, -1, 1]), buff=2)
-
-        cube_3d = cube.copy()
-        cube_2d = cube_3d.copy().stretch(0, 2)
-        cube_1d = cube_2d.copy().stretch(0, 1)
-        cube_0d = cube_1d.copy().stretch(0, 0)
-
-        cube.become(cube_0d)
-
-        self.set_camera_orientation(
-            phi=70 * DEGREES,
-            theta=-145 * DEGREES,
-        )
-        self.begin_ambient_camera_rotation(rate=0.05)
-
-        for target in [cube_1d, cube_2d, cube_3d]:
-            self.play(
-                Transform(cube, target, run_time=1.5)
-            )
-        self.wait(8)
-
-
-class ShowCubeFormationWithColor(ShowCubeFormation):
-    CONFIG = {
-        "color": True,
-    }
-
-
-class ShowRect(Scene):
-    CONFIG = {
-        "height": 1,
-        "width": 3,
-    }
-
-    def construct(self):
-        rect = Rectangle(
-            height=self.height,
-            width=self.width,
-        )
-        rect.set_color(YELLOW)
-        self.play(ShowCreationThenFadeOut(rect))
-
-
-class ShowSquare(ShowRect):
-    CONFIG = {
-        "height": 1,
-        "width": 1,
-    }
-
-
-class ShowHLine(Scene):
-    def construct(self):
-        line = Line(LEFT, RIGHT)
-        line.set_color(BLUE)
-        self.play(ShowCreationThenFadeOut(line))
-
-
-class ShowCross(Scene):
-    def construct(self):
-        cross = Cross(Square())
-        cross.set_width(3)
-        cross.set_height(1, stretch=True)
-        self.play(ShowCreation(cross))
-
-
-class TwoBodyEquations(Scene):
-    def construct(self):
-        kw = {
-            "tex_to_color_map": {
-                "x_1": LIGHT_GREY,
-                "y_1": LIGHT_GREY,
-                "x_2": BLUE,
-                "y_2": BLUE,
-                "=": WHITE,
-            }
-        }
-        equations = VGroup(
-            TexMobject(
-                "{d^2 x_1 \\over dt^2}",
-                "=",
-                "{x_2 - x_1 \\over m_1 \\left(",
-                "(x_2 - x_1)^2 + (y_2 - y_1)^2",
-                "\\right)^{3/2}",
-                **kw
-            ),
-            TexMobject(
-                "{d^2 y_1 \\over dt^2}",
-                "=",
-                "{y_2 - y_1 \\over m_1 \\left(",
-                "(x_2 - x_1)^2 + (y_2 - y_1)^2",
-                "\\right)^{3/2}",
-                **kw
-            ),
-            TexMobject(
-                "{d^2 x_2 \\over dt^2}",
-                "=",
-                "{x_1 - x_2 \\over m_2 \\left(",
-                "(x_2 - x_1)^2 + (y_2 - y_1)^2",
-                "\\right)^{3/2}",
-                **kw
-            ),
-            TexMobject(
-                "{d^2 y_2 \\over dt^2}",
-                "=",
-                "{y_1 - y_2 \\over m_2 \\left(",
-                "(x_2 - x_1)^2 + (y_2 - y_1)^2",
-                "\\right)^{3/2}",
-                **kw
-            ),
-        )
-
-        equations.arrange(DOWN, buff=LARGE_BUFF)
-        equations.set_height(6)
-        equations.to_edge(LEFT)
-
-        variables = VGroup()
-        lhss = VGroup()
-        rhss = VGroup()
-        for equation in equations:
-            variable = equation[1]
-            lhs = equation[:4]
-            rhs = equation[4:]
-            variables.add(variable)
-            lhss.add(lhs)
-            rhss.add(rhs)
-        lhss_copy = lhss.copy()
-
-        for variable, lhs in zip(variables, lhss):
-            variable.save_state()
-            variable.match_height(lhs)
-            variable.scale(0.7)
-            variable.move_to(lhs, LEFT)
-
-        self.play(LaggedStart(*[
-            FadeInFrom(v, RIGHT)
-            for v in variables
-        ]))
-        self.wait()
-        self.play(
-            LaggedStartMap(Restore, variables),
-            FadeIn(
-                lhss_copy,
-                remover=True,
-                lag_ratio=0.1,
-                run_time=2,
-            )
-        )
-        self.add(lhss)
-        self.wait()
-        self.play(LaggedStartMap(
-            FadeIn, rhss
-        ))
-        self.wait()
-        self.play(
-            LaggedStart(*[
-                ShowCreationThenFadeAround(lhs[:3])
-                for lhs in lhss
-            ])
-        )
-        self.wait()
-        self.play(
-            LaggedStartMap(
-                ShowCreationThenFadeAround,
-                rhss,
-            )
-        )
-        self.wait()
-
-
-class LaplacianIntuition(SpecialThreeDScene):
-    CONFIG = {
-        "three_d_axes_config": {
-            "x_min": -5,
-            "x_max": 5,
-            "y_min": -5,
-            "y_max": 5,
-        },
-        "surface_resolution": 32,
-    }
-
-    def construct(self):
-        axes = self.get_axes()
-        axes.scale(0.5, about_point=ORIGIN)
-        self.set_camera_to_default_position()
-        self.begin_ambient_camera_rotation()
-
-        def func(x, y):
-            return np.array([
-                x, y,
-                2.7 + 0.5 * (np.sin(x) + np.cos(y)) -
-                0.025 * (x**2 + y**2)
-            ])
-
-        surface_config = {
-            "u_min": -5,
-            "u_max": 5,
-            "v_min": -5,
-            "v_max": 5,
-            "resolution": self.surface_resolution,
-        }
-        # plane = ParametricSurface(
-        #     lambda u, v: np.array([u, v, 0]),
-        #     **surface_config
-        # )
-        # plane.set_stroke(WHITE, width=0.1)
-        # plane.set_fill(WHITE, opacity=0.1)
-        plane = Square(
-            side_length=10,
-            stroke_width=0,
-            fill_color=WHITE,
-            fill_opacity=0.1,
-        )
-        plane.center()
-        plane.set_shade_in_3d(True)
-
-        surface = ParametricSurface(
-            func, **surface_config
-        )
-        surface.set_stroke(BLUE, width=0.1)
-        surface.set_fill(BLUE, opacity=0.25)
-
-        self.add(axes, plane, surface)
-
-        point = VectorizedPoint(np.array([2, -2, 0]))
-        dot = Dot()
-        dot.set_color(GREEN)
-        dot.add_updater(lambda d: d.move_to(point))
-        line = always_redraw(lambda: DashedLine(
-            point.get_location(),
-            func(*point.get_location()[:2]),
-            background_image_file="VerticalTempGradient",
-        ))
-
-        circle = Circle(radius=0.25)
-        circle.set_color(YELLOW)
-        circle.insert_n_curves(20)
-        circle.add_updater(lambda m: m.move_to(point))
-        circle.set_shade_in_3d(True)
-        surface_circle = always_redraw(
-            lambda: circle.copy().apply_function(
-                lambda p: func(*p[:2])
-            ).shift(
-                0.02 * IN
-            ).color_using_background_image("VerticalTempGradient")
-        )
-
-        self.play(FadeInFromLarge(dot))
-        self.play(ShowCreation(line))
-        self.play(TransformFromCopy(dot, circle))
-        self.play(
-            Transform(
-                circle.copy(),
-                surface_circle.copy().clear_updaters(),
-                remover=True,
-            )
-        )
-        self.add(surface_circle)
-
-        self.wait()
-        for vect in [4 * LEFT, DOWN, 4 * RIGHT, UP]:
-            self.play(
-                point.shift, vect,
-                run_time=3,
-            )
-
-
-class StrogatzMention(PiCreatureScene):
-    def construct(self):
-        self.show_book()
-        self.show_motives()
-        self.show_pages()
-
-    def show_book(self):
-        morty = self.pi_creature
-        book = ImageMobject("InfinitePowers")
-        book.set_height(5)
-        book.to_edge(LEFT)
-
-        steve = ImageMobject("Strogatz_by_bricks")
-        steve.set_height(5)
-        steve.to_edge(LEFT)
-
-        name = TextMobject("Steven Strogatz")
-        name.match_width(steve)
-        name.next_to(steve, DOWN)
-
-        self.think(
-            "Hmm...many good\\\\lessons here...",
-            run_time=1
-        )
-        self.wait()
-        self.play(FadeInFromDown(steve))
-        self.wait()
-        self.play(
-            FadeInFrom(book, DOWN),
-            steve.shift, 4 * RIGHT,
-            RemovePiCreatureBubble(
-                morty, target_mode="thinking"
-            )
-        )
-        self.wait(3)
-        self.play(
-            FadeOut(steve),
-            FadeOut(morty),
-        )
-
-        self.book = book
-
-    def show_motives(self):
-        motives = VGroup(
-            TextMobject("1) Scratch and itch"),
-            TextMobject("2) Make people love math"),
-        )
-        motives.scale(1.5)
-        motives.arrange(
-            DOWN, LARGE_BUFF,
-            aligned_edge=LEFT,
-        )
-        motives.move_to(
-            Line(
-                self.book.get_right(),
-                FRAME_WIDTH * RIGHT / 2
-            )
-        )
-        motives.to_edge(UP)
-
-        for motive in motives:
-            self.play(FadeInFromDown(motive))
-            self.wait(2)
-        self.play(FadeOut(motives))
-
-    def show_pages(self):
-        book = self.book
-        pages = Group(*[
-            ImageMobject("IP_Sample_Page{}".format(i))
-            for i in range(1, 4)
-        ])
-        for page in pages:
-            page.match_height(book)
-            page.next_to(book, RIGHT)
-
-        last_page = VectorizedPoint()
-        for page in pages:
-            self.play(
-                FadeOut(last_page),
-                FadeIn(page)
-            )
-            self.wait()
-            last_page = page
-
-        self.play(FadeOut(last_page))
-
-    def create_pi_creature(self):
-        return Mortimer().to_corner(DR)
-
-
-class Thumbnail(Scene):
-    def construct(self):
-        image = ImageMobject("HeatSurfaceExampleFlipped")
-        image.set_height(6.5)
-        image.to_edge(DOWN, buff=-SMALL_BUFF)
-        self.add(image)
-
-        equation = TexMobject(
-            "{\\partial {T} \\over \\partial {t}}", "=",
-            "\\alpha", "\\nabla^2 {T}",
-            tex_to_color_map={
-                "{t}": YELLOW,
-                "{T}": RED,
-            }
-        )
-        equation.scale(2)
-        equation.to_edge(UP)
-
-        self.add(equation)
-
-        Group(equation, image).shift(1.5 * RIGHT)
-
-        question = TextMobject("What is\\\\this?")
-        question.scale(2.5)
-        question.to_edge(LEFT)
-        arrow = Arrow(
-            question.get_top(),
-            equation.get_left(),
-            buff=0.5,
-            path_arc=-90 * DEGREES,
-        )
-        arrow.set_stroke(width=5)
-
-        self.add(question, arrow)
-
-
-class ShowNewton(Scene):
-    def construct(self):
-        pass
-
-
-class ShowCupOfWater(Scene):
-    def construct(self):
-        pass

from_3b1b/active/diffyq/part2/wordy_scenes.py

@@ -1,785 +0,0 @@
-from manimlib.imports import *
-
-
-class WriteHeatEquationTemplate(Scene):
-    CONFIG = {
-        "tex_mobject_config": {
-            "tex_to_color_map": {
-                "{T}": WHITE,
-                "{t}": YELLOW,
-                "{x}": GREEN,
-                "{y}": RED,
-                "{z}": BLUE,
-                "\\partial": WHITE,
-                "2": WHITE,
-            },
-        },
-    }
-
-    def get_d1_equation(self):
-        return TexMobject(
-            "{\\partial {T} \\over \\partial {t}}({x}, {t})", "=",
-            "\\alpha \\cdot",
-            "{\\partial^2 {T} \\over \\partial {x}^2} ({x}, {t})",
-            **self.tex_mobject_config
-        )
-
-    def get_d1_equation_without_inputs(self):
-        return TexMobject(
-            "{\\partial {T} \\over \\partial {t}}", "=",
-            "\\alpha \\cdot",
-            "{\\partial^2 {T} \\over \\partial {x}^2}",
-            **self.tex_mobject_config
-        )
-
-    def get_d3_equation(self):
-        return TexMobject(
-            "{\\partial {T} \\over \\partial {t}}", "=",
-            "\\alpha \\left(",
-            "{\\partial^2 {T} \\over \\partial {x}^2} + ",
-            "{\\partial^2 {T} \\over \\partial {y}^2} + ",
-            "{\\partial^2 {T} \\over \\partial {z}^2}",
-            "\\right)",
-            **self.tex_mobject_config
-        )
-
-    def get_general_equation(self):
-        return TexMobject(
-            "{\\partial {T} \\over \\partial {t}}", "=",
-            "\\alpha", "\\nabla^2 {T}",
-            **self.tex_mobject_config,
-        )
-
-    def get_d3_equation_with_inputs(self):
-        return TexMobject(
-            "{\\partial {T} \\over \\partial {t}}",
-            "({x}, {y}, {z}, {t})", "=",
-            "\\alpha \\left(",
-            "{\\partial^2 {T} \\over \\partial {x}^2}",
-            "({x}, {y}, {z}, {t}) + ",
-            "{\\partial^2 {T} \\over \\partial {y}^2}",
-            "({x}, {y}, {z}, {t}) + ",
-            "{\\partial^2 {T} \\over \\partial {z}^2}",
-            "({x}, {y}, {z}, {t})",
-            "\\right)",
-            **self.tex_mobject_config
-        )
-
-    def get_d1_words(self):
-        return TextMobject("Heat equation\\\\", "(1 dimension)")
-
-    def get_d3_words(self):
-        return TextMobject("Heat equation\\\\", "(3 dimensions)")
-
-    def get_d1_group(self):
-        group = VGroup(
-            self.get_d1_words(),
-            self.get_d1_equation(),
-        )
-        group.arrange(DOWN, buff=MED_LARGE_BUFF)
-        return group
-
-    def get_d3_group(self):
-        group = VGroup(
-            self.get_d3_words(),
-            self.get_d3_equation(),
-        )
-        group.arrange(DOWN, buff=MED_LARGE_BUFF)
-        return group
-
-
-class HeatEquationIntroTitle(WriteHeatEquationTemplate):
-    def construct(self):
-        scale_factor = 1.25
-        title = TextMobject("The Heat Equation")
-        title.scale(scale_factor)
-        title.to_edge(UP)
-
-        equation = self.get_general_equation()
-        equation.scale(scale_factor)
-        equation.next_to(title, DOWN, MED_LARGE_BUFF)
-        equation.set_color_by_tex("{T}", RED)
-
-        self.play(
-            FadeInFrom(title, DOWN),
-            FadeInFrom(equation, UP),
-        )
-        self.wait()
-
-
-class BringTogether(Scene):
-    def construct(self):
-        arrows = VGroup(Vector(2 * RIGHT), Vector(2 * LEFT))
-        arrows.arrange(RIGHT, buff=2)
-        words = TextMobject("Bring together")[0]
-        words.next_to(arrows, DOWN)
-        words.save_state()
-        words.space_out_submobjects(1.2)
-
-        self.play(
-            VFadeIn(words),
-            Restore(words),
-            arrows.arrange, RIGHT, {"buff": SMALL_BUFF},
-            VFadeIn(arrows),
-        )
-        self.play(FadeOut(words), FadeOut(arrows))
-
-
-class FourierSeriesIntro(WriteHeatEquationTemplate):
-    def construct(self):
-        title_scale_value = 1.5
-
-        title = TextMobject(
-            "Fourier ", "Series",
-        )
-        title.scale(title_scale_value)
-        title.to_edge(UP)
-        title.generate_target()
-
-        details_coming = TextMobject("Details coming...")
-        details_coming.next_to(title.get_corner(DR), DOWN)
-        details_coming.set_color(LIGHT_GREY)
-
-        # physics = TextMobject("Physics")
-        heat = TextMobject("Heat")
-        heat.scale(title_scale_value)
-        physics = self.get_general_equation()
-        physics.set_color_by_tex("{T}", RED)
-        arrow1 = Arrow(LEFT, RIGHT)
-        arrow2 = Arrow(LEFT, RIGHT)
-        group = VGroup(
-            heat, arrow1, physics, arrow2, title.target
-        )
-        group.arrange(RIGHT)
-        # physics.align_to(title.target, UP)
-        group.to_edge(UP)
-
-        rot_square = Square()
-        rot_square.fade(1)
-        rot_square.add_updater(lambda m, dt: m.rotate(dt))
-
-        def update_heat_colors(heat):
-            colors = [YELLOW, RED]
-            vertices = rot_square.get_vertices()
-            letters = heat.family_members_with_points()
-            for letter, vertex in zip(letters, vertices):
-                alpha = (normalize(vertex)[0] + 1) / 2
-                i, sa = integer_interpolate(0, len(colors) - 1, alpha)
-                letter.set_color(interpolate_color(
-                    colors[i], colors[i + 1], alpha,
-                ))
-        heat.add_updater(update_heat_colors)
-
-        image = ImageMobject("Joseph Fourier")
-        image.set_height(5)
-        image.next_to(title, DOWN, LARGE_BUFF)
-        image.to_edge(LEFT)
-        name = TextMobject("Joseph", "Fourier")
-        name.next_to(image, DOWN)
-
-        bubble = ThoughtBubble(
-            height=2,
-            width=2.5,
-            direction=RIGHT,
-        )
-        bubble.set_fill(opacity=0)
-        bubble.set_stroke(WHITE)
-        bubble.set_stroke(BLACK, 5, background=True)
-        bubble.shift(heat.get_center() - bubble.get_bubble_center())
-        bubble[:-1].shift(LEFT + 0.2 * DOWN)
-        bubble[:-1].rotate(-20 * DEGREES)
-        for mob in bubble[:-1]:
-            mob.rotate(20 * DEGREES)
-
-        # self.play(FadeInFromDown(title))
-        self.add(title)
-        self.play(
-            FadeInFromDown(image),
-            TransformFromCopy(
-                title.get_part_by_tex("Fourier"),
-                name.get_part_by_tex("Fourier"),
-                path_arc=90 * DEGREES,
-            ),
-            FadeIn(name.get_part_by_tex("Joseph")),
-        )
-        self.play(Write(details_coming, run_time=1))
-        self.play(LaggedStartMap(FadeOut, details_coming[0], run_time=1))
-        self.wait()
-        self.add(rot_square)
-        self.play(
-            FadeInFrom(physics, RIGHT),
-            GrowArrow(arrow2),
-            FadeInFrom(heat, RIGHT),
-            GrowArrow(arrow1),
-            MoveToTarget(title),
-        )
-        self.play(ShowCreation(bubble))
-        self.wait(10)
-
-
-class CompareODEToPDE(Scene):
-    def construct(self):
-        pass
-
-
-class TodaysTargetWrapper(Scene):
-    def construct(self):
-        pass
-
-
-class TwoGraphTypeTitles(Scene):
-    def construct(self):
-        left_title = TextMobject(
-            "Represent time\\\\with actual time"
-        )
-        left_title.shift(FRAME_WIDTH * LEFT / 4)
-        right_title = TextMobject(
-            "Represent time\\\\with an axis"
-        )
-        right_title.shift(FRAME_WIDTH * RIGHT / 4)
-
-        titles = VGroup(left_title, right_title)
-        for title in titles:
-            title.scale(1.25)
-            title.to_edge(UP)
-
-        self.play(FadeInFromDown(right_title))
-        self.wait()
-        self.play(FadeInFromDown(left_title))
-        self.wait()
-
-
-class ShowPartialDerivativeSymbols(Scene):
-    def construct(self):
-        t2c = {
-            "{x}": GREEN,
-            "{t}": YELLOW,
-        }
-        d_derivs, del_derivs = VGroup(*[
-            VGroup(*[
-                TexMobject(
-                    "{" + sym, "T", "\\over", sym, var + "}",
-                    "(", "{x}", ",", "{t}", ")",
-                ).set_color_by_tex_to_color_map(t2c)
-                for var in ("{x}", "{t}")
-            ])
-            for sym in ("d", "\\partial")
-        ])
-        dTdx, dTdt = d_derivs
-        delTdelx, delTdelx = del_derivs
-        dels = VGroup(*it.chain(*[
-            del_deriv.get_parts_by_tex("\\partial")
-            for del_deriv in del_derivs
-        ]))
-
-        dTdx.to_edge(UP)
-        self.play(FadeInFrom(dTdx, DOWN))
-        self.wait()
-        self.play(ShowCreationThenFadeAround(dTdx[3:5]))
-        self.play(ShowCreationThenFadeAround(dTdx[:2]))
-        self.wait()
-
-        dTdt.move_to(dTdx)
-        self.play(
-            dTdx.next_to, dTdt, RIGHT, {"buff": 1.5},
-            dTdx.set_opacity, 0.5,
-            FadeInFromDown(dTdt)
-        )
-        self.wait()
-
-        for m1, m2 in zip(d_derivs, del_derivs):
-            m2.move_to(m1)
-
-        pd_words = TextMobject("Partial derivatives")
-        pd_words.next_to(del_derivs, DOWN, MED_LARGE_BUFF)
-
-        self.play(
-            Write(pd_words),
-            dTdx.set_opacity, 1,
-            run_time=1,
-        )
-        self.wait()
-        self.play(
-            ReplacementTransform(d_derivs, del_derivs)
-        )
-        self.play(
-            LaggedStartMap(
-                ShowCreationThenFadeAround,
-                dels,
-                surrounding_rectangle_config={
-                    "color": BLUE,
-                    "buff": 0.5 * SMALL_BUFF,
-                    "stroke_width": 2,
-                }
-            )
-        )
-        self.wait()
-
-        num_words = VGroup(*[
-            TextMobject(
-                "Change in $T$\\\\caused by {}",
-                "$\\partial$", "${}$".format(var),
-                arg_separator="",
-            ).set_color_by_tex_to_color_map(t2c)
-            for var in ("{x}", "{t}")
-        ])
-        num_words.scale(0.8)
-        for word, deriv in zip(num_words, del_derivs):
-            num = deriv[:2]
-            word.move_to(num, UP)
-            word.to_edge(UP, buff=MED_SMALL_BUFF)
-            deriv.rect = SurroundingRectangle(
-                num,
-                buff=SMALL_BUFF,
-                stroke_width=2,
-                color=word[-1].get_color(),
-            )
-            deriv.rect.mob = num
-            deriv.rect.add_updater(lambda r: r.move_to(r.mob))
-
-        self.play(
-            Write(num_words[1]),
-            VGroup(del_derivs, pd_words).shift, DOWN,
-            ShowCreation(del_derivs[1].rect),
-        )
-        self.play(
-            Write(num_words[0]),
-            ShowCreation(del_derivs[0].rect),
-        )
-        self.wait()
-
-
-class WriteHeatEquation(WriteHeatEquationTemplate):
-    def construct(self):
-        title = TextMobject("The Heat Equation")
-        title.to_edge(UP)
-
-        equation = self.get_d1_equation()
-        equation.next_to(title, DOWN)
-
-        eq_i = equation.index_of_part_by_tex("=")
-        dt_part = equation[:eq_i]
-        dx_part = equation[eq_i + 3:]
-        dt_rect = SurroundingRectangle(dt_part)
-        dt_rect.set_stroke(YELLOW, 2)
-        dx_rect = SurroundingRectangle(dx_part)
-        dx_rect.set_stroke(GREEN, 2)
-
-        two_outlines = equation.get_parts_by_tex("2").copy()
-        two_outlines.set_stroke(YELLOW, 2)
-        two_outlines.set_fill(opacity=0)
-
-        to_be_explained = TextMobject(
-            "To be explained shortly..."
-        )
-        to_be_explained.scale(0.7)
-        to_be_explained.next_to(equation, RIGHT, MED_LARGE_BUFF)
-        to_be_explained.fade(1)
-
-        pde = TextMobject("Partial Differential Equation")
-        pde.move_to(title)
-
-        del_outlines = equation.get_parts_by_tex("\\partial").copy()
-        del_outlines.set_stroke(YELLOW, 2)
-        del_outlines.set_fill(opacity=0)
-
-        self.play(
-            FadeInFrom(title, 0.5 * DOWN),
-            FadeInFrom(equation, 0.5 * UP),
-        )
-        self.wait()
-        self.play(ShowCreation(dt_rect))
-        self.wait()
-        self.play(TransformFromCopy(dt_rect, dx_rect))
-        self.play(ShowCreationThenDestruction(two_outlines))
-        self.wait()
-        self.play(Write(to_be_explained, run_time=1))
-        self.wait(2)
-        self.play(
-            ShowCreationThenDestruction(
-                del_outlines,
-                lag_ratio=0.1,
-            )
-        )
-        self.play(
-            FadeOutAndShift(title, UP),
-            FadeInFrom(pde, DOWN),
-            FadeOut(dt_rect),
-            FadeOut(dx_rect),
-        )
-        self.wait()
-
-
-class Show3DEquation(WriteHeatEquationTemplate):
-    def construct(self):
-        equation = self.get_d3_equation_with_inputs()
-        equation.set_width(FRAME_WIDTH - 1)
-        inputs = VGroup(*it.chain(*[
-            equation.get_parts_by_tex(s)
-            for s in ["{x}", "{y}", "{z}", "{t}"]
-        ]))
-        inputs.sort()
-        equation.to_edge(UP)
-
-        self.add(equation)
-        self.play(LaggedStartMap(
-            ShowCreationThenFadeAround, inputs,
-            surrounding_rectangle_config={
-                "buff": 0.05,
-                "stroke_width": 2,
-            }
-        ))
-        self.wait()
-
-
-class Show1DAnd3DEquations(WriteHeatEquationTemplate):
-    def construct(self):
-        d1_group = self.get_d1_group()
-        d3_group = self.get_d3_group()
-        d1_words, d1_equation = d1_group
-        d3_words, d3_equation = d3_group
-
-        groups = VGroup(d1_group, d3_group)
-        for group in groups:
-            group.arrange(DOWN, buff=MED_LARGE_BUFF)
-        groups.arrange(RIGHT, buff=1.5)
-        groups.to_edge(UP)
-
-        d3_rhs = d3_equation[9:-2]
-        d3_brace = Brace(d3_rhs, DOWN)
-        nabla_words = TextMobject("Sometimes written as")
-        nabla_words.match_width(d3_brace)
-        nabla_words.next_to(d3_brace, DOWN)
-        nabla_exp = TexMobject(
-            "\\nabla^2 {T}",
-            **self.tex_mobject_config,
-        )
-        nabla_exp.next_to(nabla_words, DOWN)
-        # nabla_group = VGroup(nabla_words, nabla_exp)
-
-        d1_group.save_state()
-        d1_group.center().to_edge(UP)
-
-        self.play(
-            Write(d1_words),
-            FadeInFrom(d1_equation, UP),
-            run_time=1,
-        )
-        self.wait(2)
-        self.play(
-            Restore(d1_group),
-            FadeInFrom(d3_group, LEFT)
-        )
-        self.wait()
-        self.play(
-            GrowFromCenter(d3_brace),
-            Write(nabla_words),
-            TransformFromCopy(d3_rhs, nabla_exp),
-            run_time=1,
-        )
-        self.wait()
-
-
-class D1EquationNoInputs(WriteHeatEquationTemplate):
-    def construct(self):
-        equation = self.get_d1_equation_without_inputs()
-        equation.to_edge(UP)
-        # i1 = equation.index_of_part_by_tex("\\partial")
-        # i2 = equation.index_of_part_by_tex("\\cdot")
-        # equation[i1:i1 + 2].set_color(RED)
-        # equation[i2 + 1:i2 + 6].set_color(RED)
-        equation.set_color_by_tex("{T}", RED)
-        self.add(equation)
-
-
-class AltHeatRHS(Scene):
-    def construct(self):
-        formula = TexMobject(
-            "{\\alpha \\over 2}", "\\Big(",
-            "T({x} - 1, {t}) + T({x} + 1, {t})"
-            "\\Big)",
-            tex_to_color_map={
-                "{x}": GREEN,
-                "{t}": YELLOW,
-            }
-        )
-        self.add(formula)
-
-
-class CompareInputsOfGeneralCaseTo1D(WriteHeatEquation):
-    def construct(self):
-        three_d_expr, one_d_expr = [
-            TexMobject(
-                "{T}(" + inputs + ", {t})",
-                **self.tex_mobject_config,
-            )
-            for inputs in ["{x}, {y}, {z}", "{x}"]
-        ]
-        for expr in three_d_expr, one_d_expr:
-            expr.scale(2)
-            expr.to_edge(UP)
-
-        x, y, z = [
-            three_d_expr.get_part_by_tex(letter)
-            for letter in ["x", "y", "z"]
-        ]
-
-        self.play(FadeInFromDown(three_d_expr))
-        self.play(LaggedStartMap(
-            ShowCreationThenFadeAround,
-            VGroup(x, y, z)
-        ))
-        self.wait()
-        low = 3
-        high = -3
-        self.play(
-            ReplacementTransform(three_d_expr[:low], one_d_expr[:low]),
-            ReplacementTransform(three_d_expr[high:], one_d_expr[high:]),
-            three_d_expr[low:high].scale, 0,
-        )
-        self.wait()
-
-
-class ShowLaplacian(WriteHeatEquation):
-    def construct(self):
-        equation = self.get_d3_equation()
-        equation.to_edge(UP, buff=MED_SMALL_BUFF)
-
-        parts = VGroup()
-        plusses = VGroup()
-        for char in "xyz":
-            index = equation.index_of_part_by_tex(
-                "{" + char + "}"
-            )
-            part = equation[index - 6:index + 3]
-            rect = SurroundingRectangle(part)
-            rect.match_color(equation[index])
-            parts.add(part)
-            part.rect = rect
-            if char in "yz":
-                plus = equation[index - 8]
-                part.plus = plus
-                plusses.add(plus)
-
-        lp = equation.get_part_by_tex("(")
-        rp = equation.get_part_by_tex(")")
-
-        for part in parts:
-            part.rp = rp.copy()
-            part.rp.next_to(part, RIGHT, SMALL_BUFF)
-            part.rp.align_to(lp, UP)
-        rp.become(parts[0].rp)
-
-        # Show new second derivatives
-        self.add(*equation)
-        self.remove(*plusses, *parts[1], *parts[2])
-        for part in parts[1:]:
-            self.play(
-                rp.become, part.rp,
-                FadeInFrom(part, LEFT),
-                Write(part.plus),
-                ShowCreation(part.rect),
-            )
-            self.play(
-                FadeOut(part.rect),
-            )
-            self.wait()
-
-        # Show laplacian
-        brace = Brace(parts, DOWN)
-        laplacian = TexMobject("\\nabla^2", "T")
-        laplacian.next_to(brace, DOWN)
-        laplacian_name = TextMobject(
-            "``Laplacian''"
-        )
-        laplacian_name.next_to(laplacian, DOWN)
-
-        T_parts = VGroup(*[part[3] for part in parts])
-        non_T_parts = VGroup(*[
-            VGroup(*part[:3], *part[4:])
-            for part in parts
-        ])
-
-        self.play(GrowFromCenter(brace))
-        self.play(Write(laplacian_name))
-        self.play(
-            TransformFromCopy(non_T_parts, laplacian[0])
-        )
-        self.play(
-            TransformFromCopy(T_parts, laplacian[1])
-        )
-        self.wait(3)
-
-
-class AskAboutActuallySolving(WriteHeatEquationTemplate):
-    def construct(self):
-        equation = self.get_d1_equation()
-        equation.center()
-
-        q1 = TextMobject("Solve for T?")
-        q1.next_to(equation, UP, LARGE_BUFF)
-        q2 = TextMobject("What does it \\emph{mean} to solve this?")
-        q2.next_to(equation, UP, LARGE_BUFF)
-        formula = TexMobject(
-            "T({x}, {t}) = \\sin\\big(a{x}\\big) e^{-\\alpha \\cdot a^2 {t}}",
-            tex_to_color_map={
-                "{x}": GREEN,
-                "{t}": YELLOW,
-            }
-        )
-        formula.next_to(equation, DOWN, LARGE_BUFF)
-        q3 = TextMobject("Is this it?")
-        arrow = Vector(LEFT, color=WHITE)
-        arrow.next_to(formula, RIGHT)
-        q3.next_to(arrow, RIGHT)
-
-        self.add(equation)
-        self.play(FadeInFromDown(q1))
-        self.wait()
-        self.play(
-            FadeInFromDown(q2),
-            q1.shift, 1.5 * UP,
-        )
-        self.play(FadeInFrom(formula, UP))
-        self.play(
-            GrowArrow(arrow),
-            FadeInFrom(q3, LEFT)
-        )
-        self.wait()
-
-
-class PDEPatreonEndscreen(PatreonEndScreen):
-    CONFIG = {
-        "specific_patrons": [
-            "Juan Benet",
-            "Vassili Philippov",
-            "Burt Humburg",
-            "Matt Russell",
-            "Scott Gray",
-            "soekul",
-            "Tihan Seale",
-            "Richard Barthel",
-            "Ali Yahya",
-            "dave nicponski",
-            "Evan Phillips",
-            "Graham",
-            "Joseph Kelly",
-            "Kaustuv DeBiswas",
-            "LambdaLabs",
-            "Lukas Biewald",
-            "Mike Coleman",
-            "Peter Mcinerney",
-            "Quantopian",
-            "Roy Larson",
-            "Scott Walter, Ph.D.",
-            "Yana Chernobilsky",
-            "Yu Jun",
-            "Jordan Scales",
-            "D. Sivakumar",
-            "Lukas -krtek.net- Novy",
-            "John Shaughnessy",
-            "Britt Selvitelle",
-            "David Gow",
-            "J",
-            "Jonathan Wilson",
-            "Joseph John Cox",
-            "Magnus Dahlström",
-            "Randy C. Will",
-            "Ryan Atallah",
-            "Luc Ritchie",
-            "1stViewMaths",
-            "Adrian Robinson",
-            "Alexis Olson",
-            "Andreas Benjamin Brössel",
-            "Andrew Busey",
-            "Ankalagon",
-            "Antoine Bruguier",
-            "Antonio Juarez",
-            "Arjun Chakroborty",
-            "Art Ianuzzi",
-            "Awoo",
-            "Bernd Sing",
-            "Boris Veselinovich",
-            "Brian Staroselsky",
-            "Chad Hurst",
-            "Charles Southerland",
-            "Chris Connett",
-            "Christian Kaiser",
-            "Clark Gaebel",
-            "Cooper Jones",
-            "Danger Dai",
-            "Dave B",
-            "Dave Kester",
-            "David B. Hill",
-            "David Clark",
-            "DeathByShrimp",
-            "Delton Ding",
-            "eaglle",
-            "emptymachine",
-            "Eric Younge",
-            "Eryq Ouithaqueue",
-            "Federico Lebron",
-            "Giovanni Filippi",
-            "Hal Hildebrand",
-            "Hitoshi Yamauchi",
-            "Isaac Jeffrey Lee",
-            "j eduardo perez",
-            "Jacob Magnuson",
-            "Jameel Syed",
-            "Jason Hise",
-            "Jeff Linse",
-            "Jeff Straathof",
-            "John Griffith",
-            "John Haley",
-            "John V Wertheim",
-            "Jonathan Eppele",
-            "Kai-Siang Ang",
-            "Kanan Gill",
-            "L0j1k",
-            "Lee Beck",
-            "Lee Redden",
-            "Linh Tran",
-            "Ludwig Schubert",
-            "Magister Mugit",
-            "Mark B Bahu",
-            "Mark Heising",
-            "Martin Price",
-            "Mathias Jansson",
-            "Matt Langford",
-            "Matt Roveto",
-            "Matthew Bouchard",
-            "Matthew Cocke",
-            "Michael Faust",
-            "Michael Hardel",
-            "Mirik Gogri",
-            "Mustafa Mahdi",
-            "Márton Vaitkus",
-            "Nero Li",
-            "Nikita Lesnikov",
-            "Omar Zrien",
-            "Owen Campbell-Moore",
-            "Peter Ehrnstrom",
-            "RedAgent14",
-            "rehmi post",
-            "Richard Burgmann",
-            "Richard Comish",
-            "Ripta Pasay",
-            "Rish Kundalia",
-            "Robert Teed",
-            "Roobie",
-            "Ryan Williams",
-            "Sachit Nagpal",
-            "Solara570",
-            "Stevie Metke",
-            "Tal Einav",
-            "Ted Suzman",
-            "Thomas Tarler",
-            "Tom Fleming",
-            "Valeriy Skobelev",
-            "Xavier Bernard",
-            "Yavor Ivanov",
-            "Yaw Etse",
-            "YinYangBalance.Asia",
-            "Zach Cardwell",
-        ],
-    }

from_3b1b/active/diffyq/part3/discrete_case.py

@@ -1,303 +0,0 @@
-from manimlib.imports import *
-from active_projects.diffyq.part2.heat_equation import *
-
-
-class ShowNewRuleAtDiscreteBoundary(DiscreteSetup):
-    CONFIG = {
-        "axes_config": {
-            "x_min": 0,
-            "stroke_width": 1,
-            "x_axis_config": {
-                "include_tip": False,
-            },
-        },
-        "freq_amplitude_pairs": [
-            (1, 0.5),
-            (2, 1),
-            (3, 0.5),
-            (4, 0.3),
-        ],
-        "v_line_class": DashedLine,
-        "v_line_config": {
-
-        },
-        "step_size": 1,
-        "wait_time": 15,
-        "alpha": 0.25,
-    }
-
-    def construct(self):
-        self.add_axes()
-        self.set_points()
-        self.show_boundary_point_influenced_by_neighbor()
-        self.add_clock()
-        self.let_evolve()
-
-    def set_points(self):
-        axes = self.axes
-        for mob in axes.family_members_with_points():
-            if isinstance(mob, Line):
-                mob.set_stroke(width=1)
-
-        step_size = self.step_size
-        xs = np.arange(
-            axes.x_min,
-            axes.x_max + step_size,
-            step_size
-        )
-
-        dots = self.dots = self.get_dots(axes, xs)
-        self.v_lines = self.get_v_lines(dots)
-        self.rod_pieces = self.get_rod_pieces(dots)
-
-        # rod_pieces
-
-        self.add(self.dots)
-        self.add(self.v_lines)
-        self.add(self.rod_pieces)
-
-    def show_boundary_point_influenced_by_neighbor(self):
-        dots = self.dots
-        ld = dots[0]
-        ld_in = dots[1]
-        rd = dots[-1]
-        rd_in = dots[-2]
-        v_len = 0.75
-        l_arrow = Vector(v_len * LEFT)
-        l_arrow.move_to(ld.get_left(), RIGHT)
-        r_arrow = Vector(v_len * RIGHT)
-        r_arrow.move_to(rd.get_right(), LEFT)
-        arrows = VGroup(l_arrow, r_arrow)
-        q_marks = VGroup(*[
-            TexMobject("?").scale(1.5).next_to(
-                arrow, arrow.get_vector()
-            )
-            for arrow in arrows
-        ])
-
-        arrows.set_color(YELLOW)
-        q_marks.set_color(YELLOW)
-
-        blocking_rects = VGroup(*[
-            BackgroundRectangle(VGroup(
-                *dots[i:-i],
-                *self.rod_pieces[i:-i]
-            ))
-            for i in [1, 2]
-        ])
-        for rect in blocking_rects:
-            rect.stretch(1.1, dim=1, about_edge=UP)
-
-        self.play(FadeIn(blocking_rects[0]))
-        self.play(
-            LaggedStartMap(ShowCreation, arrows),
-            LaggedStart(*[
-                FadeInFrom(q_mark, -arrow.get_vector())
-                for q_mark, arrow in zip(q_marks, arrows)
-            ]),
-            run_time=1.5
-        )
-        self.wait()
-
-        # Point to inward neighbor
-        new_arrows = VGroup(*[
-            Arrow(
-                d1.get_center(),
-                VGroup(d1, d2).get_center(),
-                buff=0,
-            ).match_style(l_arrow)
-            for d1, d2 in [(ld, ld_in), (rd, rd_in)]
-        ])
-        new_arrows.match_style(arrows)
-
-        l_brace = Brace(VGroup(ld, ld_in), DOWN)
-        r_brace = Brace(VGroup(rd, rd_in), DOWN)
-        braces = VGroup(l_brace, r_brace)
-        for brace in braces:
-            brace.align_to(
-                self.axes.x_axis.get_center(), UP
-            )
-            brace.shift(SMALL_BUFF * DOWN)
-            brace.add(brace.get_tex("\\Delta x"))
-
-        self.play(
-            ReplacementTransform(arrows, new_arrows),
-            FadeOut(q_marks),
-            ReplacementTransform(*blocking_rects)
-        )
-        self.wait()
-        self.play(FadeInFrom(braces, UP))
-        self.wait()
-        self.play(
-            FadeOut(new_arrows),
-            FadeOut(blocking_rects[1]),
-            FadeOut(braces),
-        )
-
-    def add_clock(self):
-        super().add_clock()
-        self.time_label.add_updater(
-            lambda d, dt: d.increment_value(dt)
-        )
-        VGroup(
-            self.clock,
-            self.time_label
-        ).shift(2 * LEFT)
-
-    def let_evolve(self):
-        dots = self.dots
-        dots.add_updater(self.update_dots)
-
-        wait_time = self.wait_time
-        self.play(
-            ClockPassesTime(
-                self.clock,
-                run_time=wait_time,
-                hours_passed=wait_time,
-            ),
-        )
-
-    #
-
-    def get_dots(self, axes, xs):
-        dots = VGroup(*[
-            Dot(axes.c2p(x, self.temp_func(x, 0)))
-            for x in xs
-        ])
-
-        max_width = 0.8 * self.step_size
-        for dot in dots:
-            dot.add_updater(self.update_dot_color)
-            if dot.get_width() > max_width:
-                dot.set_width(max_width)
-
-        return dots
-
-    def get_v_lines(self, dots):
-        return always_redraw(lambda: VGroup(*[
-            self.get_v_line(dot)
-            for dot in dots
-        ]))
-
-    def get_v_line(self, dot):
-        x_axis = self.axes.x_axis
-        bottom = dot.get_bottom()
-        x = x_axis.p2n(bottom)
-        proj_point = x_axis.n2p(x)
-        return self.v_line_class(
-            proj_point, bottom,
-            **self.v_line_config,
-        )
-
-    def get_rod_pieces(self, dots):
-        axis = self.axes.x_axis
-        factor = 1 - np.exp(-(0.8 / self.step_size)**2)
-        width = factor * self.step_size
-
-        pieces = VGroup()
-        for dot in dots:
-            piece = Line(ORIGIN, width * RIGHT)
-            piece.set_stroke(width=5)
-            piece.move_to(dot)
-            piece.set_y(axis.get_center()[1])
-            piece.dot = dot
-            piece.add_updater(
-                lambda p: p.match_color(p.dot)
-            )
-            pieces.add(piece)
-        return pieces
-
-    def update_dot_color(self, dot):
-        y = self.axes.y_axis.p2n(dot.get_center())
-        dot.set_color(self.y_to_color(y))
-
-    def update_dots(self, dots, dt):
-        for ds in zip(dots, dots[1:], dots[2:]):
-            points = [d.get_center() for d in ds]
-            x0, x1, x2 = [p[0] for p in points]
-            dx = x1 - x0
-            y0, y1, y2 = [p[1] for p in points]
-            
-            self.update_dot(
-                dot=ds[1],
-                dt=dt,
-                mean_diff=0.5 * (y2 - 2 * y1 + y0) / dx
-            )
-            if ds[0] is dots[0]:
-                self.update_dot(
-                    dot=ds[0],
-                    dt=dt,
-                    mean_diff=(y1 - y0) / dx
-                )
-            elif ds[-1] is dots[-1]:
-                self.update_dot(
-                    dot=ds[-1],
-                    dt=dt,
-                    mean_diff=(y1 - y2) / dx
-                )
-
-    def update_dot(self, dot, dt, mean_diff):
-        dot.shift(mean_diff * self.alpha * dt * UP)
-
-
-class DiscreteEvolutionPoint25(ShowNewRuleAtDiscreteBoundary):
-    CONFIG = {
-        "step_size": 0.25,
-        "alpha": 0.5,
-        "wait_time": 30,
-    }
-
-    def construct(self):
-        self.add_axes()
-        self.set_points()
-        self.add_clock()
-        self.let_evolve()
-
-
-class DiscreteEvolutionPoint1(DiscreteEvolutionPoint25):
-    CONFIG = {
-        "step_size": 0.1,
-        "v_line_config": {
-            "stroke_width": 1,
-        },
-        "wait_time": 30,
-    }
-
-
-class FlatEdgesForDiscreteEvolution(DiscreteEvolutionPoint1):
-    CONFIG = {
-        "wait_time": 20,
-        "step_size": 0.1,
-    }
-
-    def let_evolve(self):
-        lines = VGroup(*[
-            Line(LEFT, RIGHT)
-            for x in range(2)
-        ])
-        lines.set_width(1.5)
-        lines.set_stroke(WHITE, 5, opacity=0.5)
-        lines.add_updater(self.update_lines)
-
-        turn_animation_into_updater(
-            ShowCreation(lines, run_time=2)
-        )
-        self.add(lines)
-
-        super().let_evolve()
-
-    def update_lines(self, lines):
-        dots = self.dots
-        for line, dot in zip(lines, [dots[0], dots[-1]]):
-            line.move_to(dot)
-
-
-class FlatEdgesForDiscreteEvolutionTinySteps(FlatEdgesForDiscreteEvolution):
-    CONFIG = {
-        "step_size": 0.025,
-        "wait_time": 10,
-        "v_line_class": Line,
-        "v_line_config": {
-            "stroke_opacity": 0.5,
-        }
-    }

from_3b1b/active/diffyq/part3/pi_creature_scenes.py

@@ -1,175 +0,0 @@
-from manimlib.imports import *
-from active_projects.diffyq.part2.wordy_scenes import *
-
-
-class IveHeardOfThis(TeacherStudentsScene):
-    def construct(self):
-        point = VectorizedPoint()
-        point.move_to(3 * RIGHT + 2 * UP)
-        self.student_says(
-            "I've heard\\\\", "of this!",
-            student_index=1,
-            target_mode="hooray",
-            bubble_kwargs={
-                "height": 3,
-                "width": 3,
-                "direction": RIGHT,
-            },
-            run_time=1,
-        )
-        self.change_student_modes(
-            "thinking", "hooray", "thinking",
-            look_at_arg=point,
-            added_anims=[self.teacher.change, "happy"]
-        )
-        self.wait(3)
-        self.student_says(
-            "But who\\\\", "cares?",
-            student_index=1,
-            target_mode="maybe",
-            bubble_kwargs={
-                "direction": RIGHT,
-                "width": 3,
-                "height": 3,
-            },
-            run_time=1,
-        )
-        self.change_student_modes(
-            "pondering", "maybe", "pondering",
-            look_at_arg=point,
-            added_anims=[self.teacher.change, "guilty"]
-        )
-        self.wait(5)
-
-
-class InFouriersShoes(PiCreatureScene, WriteHeatEquationTemplate):
-    def construct(self):
-        randy = self.pi_creature
-        fourier = ImageMobject("Joseph Fourier")
-        fourier.set_height(4)
-        fourier.next_to(randy, RIGHT, LARGE_BUFF)
-        fourier.align_to(randy, DOWN)
-
-        equation = self.get_d1_equation()
-        equation.next_to(fourier, UP, MED_LARGE_BUFF)
-
-        decades = list(range(1740, 2040, 20))
-        time_line = NumberLine(
-            x_min=decades[0],
-            x_max=decades[-1],
-            tick_frequency=1,
-            tick_size=0.05,
-            longer_tick_multiple=4,
-            unit_size=0.2,
-            numbers_with_elongated_ticks=decades,
-            numbers_to_show=decades,
-            decimal_number_config={
-                "group_with_commas": False,
-            },
-            stroke_width=2,
-        )
-        time_line.add_numbers()
-        time_line.move_to(ORIGIN, RIGHT)
-        time_line.to_edge(UP)
-        triangle = ArrowTip(start_angle=-90 * DEGREES)
-        triangle.set_height(0.25)
-        triangle.move_to(time_line.n2p(2019), DOWN)
-        triangle.set_color(WHITE)
-
-        self.play(FadeInFrom(fourier, 2 * LEFT))
-        self.play(randy.change, "pondering")
-        self.wait()
-        self.play(
-            DrawBorderThenFill(triangle, run_time=1),
-            FadeInFromDown(equation),
-            FadeIn(time_line),
-        )
-        self.play(
-            Animation(triangle),
-            ApplyMethod(
-                time_line.shift,
-                time_line.n2p(2019) - time_line.n2p(1822),
-                run_time=5
-            ),
-        )
-        self.wait()
-
-
-class SineCurveIsUnrealistic(TeacherStudentsScene):
-    def construct(self):
-        self.student_says(
-            "But that would\\\\never happen!",
-            student_index=1,
-            bubble_kwargs={
-                "direction": RIGHT,
-                "height": 3,
-                "width": 4,
-            },
-            target_mode="angry"
-        )
-        self.change_student_modes(
-            "guilty", "angry", "hesitant",
-            added_anims=[
-                self.teacher.change, "tease"
-            ]
-        )
-        self.wait(3)
-        self.play(
-            RemovePiCreatureBubble(self.students[1]),
-            self.teacher.change, "raise_right_hand"
-        )
-        self.change_all_student_modes(
-            "pondering",
-            look_at_arg=3 * UP,
-        )
-        self.wait(5)
-
-
-class IfOnly(TeacherStudentsScene):
-    def construct(self):
-        self.teacher_says(
-            "If only!",
-            target_mode="angry"
-        )
-        self.change_all_student_modes(
-            "confused",
-            look_at_arg=self.screen
-        )
-        self.wait(3)
-
-
-class SoWeGotNowhere(TeacherStudentsScene):
-    def construct(self):
-        self.student_says(
-            "So we've gotten\\\\nowhere!",
-            target_mode="angry",
-            added_anims=[
-                self.teacher.change, "guilty"
-            ]
-        )
-        self.change_all_student_modes("angry")
-        self.wait()
-        text = TexMobject(
-            "&\\text{Actually,}\\\\",
-            "&\\sin\\left({x}\\right)"
-            "e^{-\\alpha {t}}\\\\",
-            "&\\text{isn't far off.}",
-            tex_to_color_map={
-                "{x}": GREEN,
-                "{t}": YELLOW,
-            }
-        )
-        text.scale(0.8)
-        self.teacher_says(
-            text,
-            content_introduction_class=FadeIn,
-            bubble_kwargs={
-                "width": 4,
-                "height": 3.5,
-            }
-        )
-        self.change_all_student_modes(
-            "pondering",
-            look_at_arg=self.screen
-        )
-        self.wait(3)

from_3b1b/active/diffyq/part3/wordy_scenes.py

@@ -1,919 +0,0 @@
-from manimlib.imports import *
-from active_projects.diffyq.part2.wordy_scenes import *
-
-
-class ThreeMainObservations(Scene):
-    def construct(self):
-        fourier = ImageMobject("Joseph Fourier")
-        name = TextMobject("Joseph Fourier")
-        name.match_width(fourier)
-        name.next_to(fourier, DOWN, SMALL_BUFF)
-        fourier.add(name)
-        fourier.set_height(5)
-        fourier.to_corner(DR)
-        fourier.shift(LEFT)
-        bubble = ThoughtBubble(
-            direction=RIGHT,
-            height=3,
-            width=4,
-        )
-        bubble.move_tip_to(fourier.get_corner(UL) + 0.5 * DR)
-
-        observations = VGroup(
-            TextMobject(
-                "1)",
-                "Sine = Nice",
-            ),
-            TextMobject(
-                "2)",
-                "Linearity"
-            ),
-            TextMobject(
-                "3)",
-                "Fourier series"
-            ),
-        )
-        # heart = SuitSymbol("hearts")
-        # heart.replace(observations[0][2])
-        # observations[0][2].become(heart)
-        # observations[0][1].add(happiness)
-        # observations[2][2].align_to(
-        #     observations[2][1], LEFT,
-        # )
-
-        observations.arrange(
-            DOWN,
-            aligned_edge=LEFT,
-            buff=2 * LARGE_BUFF,
-        )
-        observations.set_height(FRAME_HEIGHT - 2)
-        observations.to_corner(UL, buff=LARGE_BUFF)
-
-        self.add(fourier)
-        self.play(ShowCreation(bubble))
-        self.wait()
-        self.play(LaggedStart(*[
-            TransformFromCopy(bubble, observation[0])
-            for observation in observations
-        ], lag_ratio=0.2))
-        self.play(
-            FadeOut(fourier),
-            FadeOut(bubble),
-        )
-        self.wait()
-        for obs in observations:
-            self.play(FadeInFrom(obs[1], LEFT))
-            self.wait()
-
-
-class LastChapterWrapper(Scene):
-    def construct(self):
-        full_rect = FullScreenFadeRectangle(
-            fill_color=DARK_GREY,
-            fill_opacity=1,
-        )
-        rect = ScreenRectangle(height=6)
-        rect.set_stroke(WHITE, 2)
-        rect.set_fill(BLACK, 1)
-        title = TextMobject("Last chapter")
-        title.scale(2)
-        title.to_edge(UP)
-        rect.next_to(title, DOWN)
-
-        self.add(full_rect)
-        self.play(
-            FadeIn(rect),
-            Write(title, run_time=2),
-        )
-        self.wait()
-
-
-class ThreeConstraints(WriteHeatEquationTemplate):
-    def construct(self):
-        self.cross_out_solving()
-        self.show_three_conditions()
-
-    def cross_out_solving(self):
-        equation = self.get_d1_equation()
-        words = TextMobject("Solve this equation")
-        words.to_edge(UP)
-        equation.next_to(words, DOWN)
-        cross = Cross(words)
-
-        self.add(words, equation)
-        self.wait()
-        self.play(ShowCreation(cross))
-        self.wait()
-
-        self.equation = equation
-        self.to_remove = VGroup(words, cross)
-
-    def show_three_conditions(self):
-        equation = self.equation
-        to_remove = self.to_remove
-
-        title = TexMobject(
-            "\\text{Constraints }"
-            "T({x}, {t})"
-            "\\text{ must satisfy:}",
-            **self.tex_mobject_config
-        )
-        title.to_edge(UP)
-
-        items = VGroup(
-            TextMobject("1)", "The PDE"),
-            TextMobject("2)", "Boundary condition"),
-            TextMobject("3)", "Initial condition"),
-        )
-        items.scale(0.7)
-        items.arrange(RIGHT, buff=LARGE_BUFF)
-        items.set_width(FRAME_WIDTH - 2)
-        items.next_to(title, DOWN, LARGE_BUFF)
-        items[1].set_color(MAROON_B)
-        items[2].set_color(RED)
-
-        bc_paren = TextMobject("(Explained soon)")
-        bc_paren.scale(0.7)
-        bc_paren.next_to(items[1], DOWN)
-
-        self.play(
-            FadeInFromDown(title),
-            FadeOutAndShift(to_remove, UP),
-            equation.scale, 0.6,
-            equation.next_to, items[0], DOWN,
-            equation.shift_onto_screen,
-            LaggedStartMap(FadeIn, [
-                items[0],
-                items[1][0],
-                items[2][0],
-            ])
-        )
-        self.wait()
-        self.play(Write(items[1][1]))
-        bc_paren.match_y(equation)
-        self.play(FadeInFrom(bc_paren, UP))
-        self.wait(2)
-        self.play(Write(items[2][1]))
-        self.wait(2)
-
-        self.title = title
-        self.items = items
-        self.pde = equation
-        self.bc_paren = bc_paren
-
-
-class RectAroundEquation(WriteHeatEquationTemplate):
-    def construct(self):
-        eq = self.get_d1_equation()
-        self.play(ShowCreationThenFadeAround(eq))
-
-
-class BorderRect(Scene):
-    def construct(self):
-        rect = FullScreenFadeRectangle()
-        rect.set_stroke(WHITE, 3)
-        rect.set_fill(opacity=0)
-        self.add(rect)
-
-
-class SeekIdealized(Scene):
-    def construct(self):
-        phrases = VGroup(*[
-            TextMobject(
-                "Seek", text, "problems",
-                tex_to_color_map={
-                    "realistic": GREEN,
-                    "{idealized}": YELLOW,
-                    "over-idealized": YELLOW,
-                    "general": BLUE,
-                }
-            )
-            for text in [
-                "realistic",
-                "{idealized}",
-                "over-idealized",
-                "general",
-            ]
-        ])
-        phrases.scale(2)
-        words = VGroup()
-        for phrase in phrases:
-            phrase.center()
-            word = phrase[1]
-            words.add(word)
-            phrase.remove(word)
-        arrow = Vector(DOWN)
-        arrow.set_stroke(WHITE, 6)
-        arrow.next_to(words[3], UP)
-        low_arrow = arrow.copy()
-        low_arrow.next_to(words[3], DOWN)
-
-        solutions = TextMobject("solutions")
-        solutions.scale(2)
-        solutions.move_to(phrases[3][1], UL)
-        models = TextMobject("models")
-        models.scale(2)
-        models.next_to(
-            words[0], RIGHT, buff=0.35,
-            aligned_edge=DOWN
-        )
-
-        phrases.center()
-        phrase = phrases[0]
-
-        self.add(phrase)
-        self.add(words[0])
-        self.wait()
-        words[0].save_state()
-        self.play(
-            words[0].to_edge, DOWN,
-            words[0].set_opacity, 0.5,
-            Transform(phrase, phrases[1]),
-            FadeInFrom(words[1], UP)
-        )
-        self.wait()
-        # self.play(
-        #     words[1].move_to, words[2], RIGHT,
-        #     FadeIn(words[2]),
-        #     Transform(phrase, phrases[2])
-        # )
-        # self.wait()
-        self.play(
-            words[1].next_to, arrow, UP,
-            ShowCreation(arrow),
-            MaintainPositionRelativeTo(
-                phrase, words[1]
-            ),
-            FadeInFrom(solutions, LEFT),
-            FadeIn(words[3]),
-        )
-        self.wait()
-
-        words[0].generate_target()
-        words[0].target.next_to(low_arrow, DOWN)
-        words[0].target.set_opacity(1)
-        models.shift(
-            words[0].target.get_center() -
-            words[0].saved_state.get_center()
-        )
-        self.play(
-            MoveToTarget(words[0]),
-            ShowCreation(low_arrow),
-            FadeInFrom(models, LEFT)
-        )
-        self.wait()
-
-
-class SecondDerivativeOfSine(Scene):
-    def construct(self):
-        equation = TexMobject(
-            "{d^2 \\over d{x}^2}",
-            "\\cos\\left({x}\\right) =",
-            "-\\cos\\left({x}\\right)",
-            tex_to_color_map={
-                "{x}": GREEN,
-            }
-        )
-
-        self.add(equation)
-
-
-class EquationAboveSineAnalysis(WriteHeatEquationTemplate):
-    def construct(self):
-        equation = self.get_d1_equation()
-        equation.to_edge(UP)
-        equation.shift(2 * LEFT)
-        eq_index = equation.index_of_part_by_tex("=")
-        lhs = equation[:eq_index]
-        eq = equation[eq_index]
-        rhs = equation[eq_index + 1:]
-        t_terms = equation.get_parts_by_tex("{t}")[1:]
-        t_terms.save_state()
-        zeros = VGroup(*[
-            TexMobject("0").replace(t, dim_to_match=1)
-            for t in t_terms
-        ])
-        zeros.align_to(t_terms, DOWN)
-        new_rhs = TexMobject(
-            "=", "-\\alpha \\cdot {T}", "({x}, 0)",
-            **self.tex_mobject_config
-        )
-        # new_rhs.move_to(equation.get_right())
-        # new_rhs.next_to(equation, DOWN, MED_LARGE_BUFF)
-        # new_rhs.align_to(eq, LEFT)
-        new_rhs.next_to(equation, RIGHT)
-        new_rhs.shift(SMALL_BUFF * DOWN)
-
-        self.add(equation)
-        self.play(ShowCreationThenFadeAround(rhs))
-        self.wait()
-        self.play(
-            FadeOutAndShift(t_terms, UP),
-            FadeInFrom(zeros, DOWN),
-        )
-        t_terms.fade(1)
-        self.wait()
-        self.play(
-            # VGroup(equation, zeros).next_to,
-            # new_rhs, LEFT,
-            FadeIn(new_rhs),
-        )
-        self.wait()
-        self.play(
-            VGroup(
-                lhs[6:],
-                eq,
-                rhs,
-                new_rhs[0],
-                new_rhs[-3:],
-                zeros,
-            ).fade, 0.5,
-        )
-        self.play(ShowCreationThenFadeAround(lhs[:6]))
-        self.play(ShowCreationThenFadeAround(new_rhs[1:-3]))
-        self.wait()
-
-
-class ExpVideoWrapper(Scene):
-    def construct(self):
-        self.add(FullScreenFadeRectangle(
-            fill_color=DARKER_GREY,
-            fill_opacity=1,
-        ))
-
-        screen = ImageMobject("eoc_chapter5_thumbnail")
-        screen.set_height(6)
-        rect = SurroundingRectangle(screen, buff=0)
-        rect.set_stroke(WHITE, 2)
-        screen.add(rect)
-        title = TextMobject("Need a refresher?")
-        title.scale(1.5)
-        title.to_edge(UP)
-        screen.next_to(title, DOWN)
-
-        screen.center()
-        self.play(
-            # FadeInFrom(title, LEFT),
-            FadeInFrom(screen, DOWN),
-        )
-        self.wait()
-
-
-class ShowSinExpDerivatives(WriteHeatEquationTemplate):
-    CONFIG = {
-        "tex_mobject_config": {
-            "tex_to_color_map": {
-                "{0}": WHITE,
-                "\\partial": WHITE,
-                "=": WHITE,
-            }
-        }
-    }
-
-    def construct(self):
-        pde = self.get_d1_equation_without_inputs()
-        pde.to_edge(UP)
-        pde.generate_target()
-
-        new_rhs = TexMobject(
-            "=- \\alpha \\cdot T",
-            **self.tex_mobject_config,
-        )
-        new_rhs.next_to(pde, RIGHT)
-        new_rhs.align_to(pde.get_part_by_tex("alpha"), DOWN)
-
-        equation1 = TexMobject(
-            "T({x}, {0}) = \\sin\\left({x}\\right)",
-            **self.tex_mobject_config
-        )
-        equation2 = TexMobject(
-            "T({x}, {t}) = \\sin\\left({x}\\right)",
-            "e^{-\\alpha{t}}",
-            **self.tex_mobject_config
-        )
-        for eq in equation1, equation2:
-            eq.next_to(pde, DOWN, MED_LARGE_BUFF)
-
-        eq2_part1 = equation2[:len(equation1)]
-        eq2_part2 = equation2[len(equation1):]
-
-        # Rectangles
-        exp_rect = SurroundingRectangle(eq2_part2)
-        exp_rect.set_stroke(RED, 3)
-        sin_rect = SurroundingRectangle(
-            eq2_part1[-3:]
-        )
-        sin_rect.set_color(BLUE)
-
-        VGroup(pde.target, new_rhs).center().to_edge(UP)
-
-        # Show proposed solution
-        self.add(pde)
-        self.add(equation1)
-        self.wait()
-        self.play(
-            MoveToTarget(pde),
-            FadeInFrom(new_rhs, LEFT)
-        )
-        self.wait()
-        self.play(
-            ReplacementTransform(equation1, eq2_part1),
-            FadeIn(eq2_part2),
-        )
-        self.play(ShowCreation(exp_rect))
-        self.wait()
-        self.play(FadeOut(exp_rect))
-
-        # Take partial derivatives wrt x
-        q_mark = TexMobject("?")
-        q_mark.next_to(pde.get_part_by_tex("="), UP)
-        q_mark.set_color(RED)
-
-        arrow1 = Vector(3 * DOWN + 1 * RIGHT, color=WHITE)
-        arrow1.scale(1.2 / arrow1.get_length())
-        arrow1.next_to(
-            eq2_part2.get_corner(DL),
-            DOWN, MED_LARGE_BUFF
-        )
-        ddx_label1 = TexMobject(
-            "\\partial \\over \\partial {x}",
-            **self.tex_mobject_config,
-        )
-        ddx_label1.scale(0.7)
-        ddx_label1.next_to(
-            arrow1.point_from_proportion(0.8),
-            UR, SMALL_BUFF
-        )
-
-        pde_ddx = VGroup(
-            *pde.get_parts_by_tex("\\partial")[2:],
-            pde.get_parts_by_tex("\\over")[1],
-            pde.get_part_by_tex("{x}"),
-        )
-        pde_ddx_rect = SurroundingRectangle(pde_ddx)
-        pde_ddx_rect.set_color(GREEN)
-
-        eq2_part2_rect = SurroundingRectangle(eq2_part2)
-
-        dx = TexMobject(
-            "\\cos\\left({x}\\right)", "e^{-\\alpha {t}}",
-            **self.tex_mobject_config
-        )
-        ddx = TexMobject(
-            "-\\sin\\left({x}\\right)", "e^{-\\alpha {t}}",
-            **self.tex_mobject_config
-        )
-        dx.next_to(arrow1, DOWN)
-        dx.align_to(eq2_part2, RIGHT)
-        x_shift = arrow1.get_end()[0] - arrow1.get_start()[0]
-        x_shift *= 2
-        dx.shift(x_shift * RIGHT)
-        arrow2 = arrow1.copy()
-        arrow2.next_to(dx, DOWN)
-        arrow2.shift(MED_SMALL_BUFF * RIGHT)
-        dx_arrows = VGroup(arrow1, arrow2)
-
-        ddx_label2 = ddx_label1.copy()
-        ddx_label2.shift(
-            arrow2.get_center() - arrow1.get_center()
-        )
-        ddx.next_to(arrow2, DOWN)
-        ddx.align_to(eq2_part2, RIGHT)
-        ddx.shift(2 * x_shift * RIGHT)
-
-        rhs = equation2[-6:]
-
-        self.play(
-            FadeInFromDown(q_mark)
-        )
-        self.play(
-            ShowCreation(pde_ddx_rect)
-        )
-        self.wait()
-        self.play(
-            LaggedStart(
-                GrowArrow(arrow1),
-                GrowArrow(arrow2),
-            ),
-            TransformFromCopy(
-                pde_ddx[0], ddx_label1
-            ),
-            TransformFromCopy(
-                pde_ddx[0], ddx_label2
-            ),
-        )
-        self.wait()
-        self.play(
-            TransformFromCopy(rhs, dx)
-        )
-        self.wait()
-        self.play(
-            FadeIn(eq2_part2_rect)
-        )
-        self.play(
-            Transform(
-                eq2_part2_rect,
-                SurroundingRectangle(dx[-3:])
-            )
-        )
-        self.play(
-            FadeOut(eq2_part2_rect)
-        )
-        self.wait()
-        self.play(
-            TransformFromCopy(dx, ddx)
-        )
-        self.play(
-            FadeIn(
-                SurroundingRectangle(ddx).match_style(
-                    pde_ddx_rect
-                )
-            )
-        )
-        self.wait()
-
-        # Take partial derivative wrt t
-        pde_ddt = pde[:pde.index_of_part_by_tex("=") - 1]
-        pde_ddt_rect = SurroundingRectangle(pde_ddt)
-
-        dt_arrow = Arrow(
-            arrow1.get_start(),
-            arrow2.get_end() + RIGHT,
-            buff=0
-        )
-        dt_arrow.flip(UP)
-        dt_arrow.next_to(dx_arrows, LEFT, MED_LARGE_BUFF)
-
-        dt_label = TexMobject(
-            "\\partial \\over \\partial {t}",
-            **self.tex_mobject_config,
-        )
-        dt_label.scale(1)
-        dt_label.next_to(
-            dt_arrow.get_center(), UL,
-            SMALL_BUFF,
-        )
-
-        rhs_copy = rhs.copy()
-        rhs_copy.next_to(dt_arrow.get_end(), DOWN)
-        rhs_copy.shift(MED_LARGE_BUFF * LEFT)
-        rhs_copy.match_y(ddx)
-
-        minus_alpha_in_exp = rhs_copy[-3][1:].copy()
-        minus_alpha_in_exp.set_color(RED)
-        minus_alpha = TexMobject("-\\alpha")
-        minus_alpha.next_to(rhs_copy, LEFT)
-        minus_alpha.align_to(rhs_copy[0][0], DOWN)
-        dot = TexMobject("\\cdot")
-        dot.move_to(midpoint(
-            minus_alpha.get_right(),
-            rhs_copy.get_left(),
-        ))
-
-        self.play(
-            TransformFromCopy(
-                pde_ddx_rect,
-                pde_ddt_rect,
-            )
-        )
-        self.play(
-            GrowArrow(dt_arrow),
-            TransformFromCopy(
-                pde_ddt,
-                dt_label,
-            )
-        )
-        self.wait()
-        self.play(TransformFromCopy(rhs, rhs_copy))
-        self.play(FadeIn(minus_alpha_in_exp))
-        self.play(
-            ApplyMethod(
-                minus_alpha_in_exp.replace, minus_alpha,
-                path_arc=TAU / 4
-            ),
-            FadeIn(dot),
-        )
-        self.play(
-            FadeIn(minus_alpha),
-            FadeOut(minus_alpha_in_exp),
-        )
-        self.wait()
-        rhs_copy.add(minus_alpha, dot)
-        self.play(
-            FadeIn(SurroundingRectangle(rhs_copy))
-        )
-        self.wait()
-
-        #
-        checkmark = TexMobject("\\checkmark")
-        checkmark.set_color(GREEN)
-        checkmark.move_to(q_mark, DOWN)
-        self.play(
-            FadeInFromDown(checkmark),
-            FadeOutAndShift(q_mark, UP)
-        )
-        self.wait()
-
-
-class DerivativesOfLinearFunction(WriteHeatEquationTemplate):
-    CONFIG = {
-        "tex_mobject_config": {
-            "tex_to_color_map": {
-                "{c}": WHITE,
-            }
-        }
-    }
-
-    def construct(self):
-        func = TexMobject(
-            "T({x}, {t}) = {c} \\cdot {x}",
-            **self.tex_mobject_config
-        )
-        dx_T = TexMobject("{c}", **self.tex_mobject_config)
-        ddx_T = TexMobject("0")
-        dt_T = TexMobject("0")
-
-        for mob in func, dx_T, ddx_T, dt_T:
-            mob.scale(1.5)
-
-        func.generate_target()
-
-        arrows = VGroup(*[
-            Vector(1.5 * RIGHT, color=WHITE)
-            for x in range(3)
-        ])
-        dx_arrows = arrows[:2]
-        dt_arrow = arrows[2]
-        dt_arrow.rotate(-TAU / 4)
-        dx_group = VGroup(
-            func.target,
-            dx_arrows[0],
-            dx_T,
-            dx_arrows[1],
-            ddx_T,
-        )
-        dx_group.arrange(RIGHT)
-        for arrow, char, vect in zip(arrows, "xxt", [UP, UP, RIGHT]):
-            label = TexMobject(
-                "\\partial \\over \\partial {%s}" % char,
-                **self.tex_mobject_config
-            )
-            label.scale(0.7)
-            label.next_to(arrow.get_center(), vect)
-            arrow.add(label)
-
-        dt_arrow.shift(
-            func.target[-3:].get_bottom() + MED_SMALL_BUFF * DOWN -
-            dt_arrow.get_start(),
-        )
-        dt_T.next_to(dt_arrow.get_end(), DOWN)
-
-        self.play(FadeInFromDown(func))
-        self.wait()
-        self.play(
-            MoveToTarget(func),
-            LaggedStartMap(Write, dx_arrows),
-            run_time=1,
-        )
-        self.play(
-            TransformFromCopy(func[-3:], dx_T),
-            path_arc=-TAU / 4,
-        )
-        self.play(
-            TransformFromCopy(dx_T, ddx_T),
-            path_arc=-TAU / 4,
-        )
-        self.wait()
-
-        # dt
-        self.play(Write(dt_arrow))
-        self.play(
-            TransformFromCopy(func[-3:], dt_T)
-        )
-        self.wait()
-
-
-class FlatAtBoundaryWords(Scene):
-    def construct(self):
-        words = self.get_bc_words()
-        self.play(Write(words))
-        self.wait()
-
-    def get_bc_words(self):
-        return TextMobject(
-            "Flat at boundary\\\\"
-            "for all", "${t}$", "$> 0$",
-        )
-
-
-class WriteOutBoundaryCondition(FlatAtBoundaryWords, ThreeConstraints, MovingCameraScene):
-    def construct(self):
-        self.force_skipping()
-        ThreeConstraints.construct(self)
-        self.revert_to_original_skipping_status()
-
-        self.add_ic()
-        self.write_bc_words()
-        self.write_bc_equation()
-
-    def add_ic(self):
-        image = ImageMobject("temp_initial_condition_example")
-        image.set_width(3)
-        border = SurroundingRectangle(image, buff=SMALL_BUFF)
-        border.shift(SMALL_BUFF * UP)
-        border.set_stroke(WHITE, 2)
-        group = Group(image, border)
-        group.next_to(self.items[2], DOWN)
-        self.add(group)
-
-    def write_bc_words(self):
-        bc_paren = self.bc_paren
-        bc_words = self.get_bc_words()
-        bc_words.match_width(self.items[1][1])
-        bc_words.move_to(bc_paren, UP)
-        bc_words.set_color_by_tex("{t}", YELLOW)
-
-        self.play(ShowCreationThenFadeAround(
-            VGroup(self.items[0], self.pde)
-        ))
-        self.play(
-            FadeOutAndShift(bc_paren, UP),
-            FadeInFrom(bc_words, DOWN),
-        )
-        self.wait()
-
-        self.bc_words = bc_words
-
-    def write_bc_equation(self):
-        bc_words = self.bc_words
-
-        equation = TexMobject(
-            "{\\partial {T} \\over \\partial {x}}(0, {t}) = ",
-            "{\\partial {T} \\over \\partial {x}}(L, {t}) = ",
-            "0",
-            **self.tex_mobject_config,
-        )
-        equation.next_to(bc_words, DOWN, MED_LARGE_BUFF)
-
-        self.play(
-            self.camera_frame.shift, 0.8 * DOWN,
-        )
-        self.play(FadeInFrom(equation, UP))
-        self.wait()
-
-
-class HeatEquationFrame(WriteHeatEquationTemplate):
-    def construct(self):
-        equation = self.get_d1_equation()
-        equation.to_edge(UP, buff=MED_SMALL_BUFF)
-
-        ddx = equation[-11:]
-        dt = equation[:11]
-
-        full_rect = FullScreenFadeRectangle(
-            fill_color=DARK_GREY,
-            fill_opacity=1,
-        )
-        smaller_rect = ScreenRectangle(
-            height=6,
-            fill_color=BLACK,
-            fill_opacity=1,
-            stroke_color=WHITE,
-            stroke_width=2,
-        )
-        smaller_rect.next_to(equation, DOWN)
-
-        self.add(full_rect)
-        self.add(smaller_rect)
-        self.add(equation)
-        self.wait()
-        self.play(ShowCreationThenFadeAround(
-            ddx,
-            surrounding_rectangle_config={
-                "stroke_color": GREEN,
-            }
-        ))
-        self.wait()
-        self.play(ShowCreationThenFadeAround(dt))
-        self.wait()
-
-
-class CompareFreqDecays1to2(Scene):
-    CONFIG = {
-        "freqs": [1, 2]
-    }
-
-    def construct(self):
-        background = FullScreenFadeRectangle(
-            fill_color=DARKER_GREY,
-            fill_opacity=1,
-        )
-
-        screens = VGroup(*[
-            ScreenRectangle(
-                height=4,
-                fill_color=BLACK,
-                fill_opacity=1,
-                stroke_width=1,
-                stroke_color=WHITE,
-            )
-            for x in range(2)
-        ])
-        screens.arrange(RIGHT)
-        screens.set_width(FRAME_WIDTH - 1)
-
-        formulas = VGroup(*[
-            self.get_formula(freq)
-            for freq in self.freqs
-        ])
-        for formula, screen in zip(formulas, screens):
-            formula.next_to(screen, UP)
-
-        self.add(background)
-        self.add(screens)
-        self.add(formulas)
-        self.wait()
-
-    def get_formula(self, freq):
-        f_str = str(freq)
-        return TexMobject(
-            "\\cos\\left(%s \\cdot {x}\\right)" % f_str,
-            "e^{-\\alpha \\cdot %s^2 \\cdot {t}}" % f_str,
-            tex_to_color_map={
-                "{x}": GREEN,
-                "{t}": YELLOW,
-                f_str: MAROON_B,
-            }
-        )
-
-
-class CompareFreqDecays1to4(CompareFreqDecays1to2):
-    CONFIG = {
-        "freqs": [1, 4],
-    }
-
-
-class CompareFreqDecays2to4(CompareFreqDecays1to2):
-    CONFIG = {
-        "freqs": [2, 4],
-    }
-
-
-class WorryAboutGenerality(TeacherStudentsScene, WriteHeatEquationTemplate):
-    def construct(self):
-        eq = self.get_d1_equation()
-        diffyq = self.get_diffyq_set()
-        is_in = TexMobject("\\in")
-        is_in.scale(2)
-
-        group = VGroup(eq, is_in, diffyq)
-        group.arrange(RIGHT, buff=MED_LARGE_BUFF)
-        group.to_edge(UP)
-
-        arrow = Vector(DOWN)
-        arrow.set_stroke(WHITE, 5)
-        arrow.next_to(eq, DOWN)
-        themes = TextMobject("Frequent themes")
-        themes.scale(1.5)
-        themes.next_to(arrow, DOWN)
-
-        self.play(
-            self.get_student_changes(
-                "sad", "tired", "pleading"
-            ),
-            self.teacher.change, "raise_right_hand",
-            FadeInFromDown(eq)
-        )
-        self.play(Write(group[1:]))
-        self.wait(2)
-        self.play(
-            ShowCreation(arrow),
-            self.get_student_changes(*3 * ["pondering"]),
-        )
-        self.play(
-            FadeInFrom(themes, UP),
-            self.get_student_changes(*3 * ["thinking"]),
-            self.teacher.change, "happy"
-        )
-        self.wait(4)
-
-
-    # def get_d1_equation(self):
-    #     result = super().get_d1_equation()
-    #     lp, rp = parens = TexMobject("(", ")")
-    #     parens.match_height(result)
-    #     lp.next_to(result, LEFT, SMALL_BUFF)
-    #     rp.next_to(result, RIGHT, SMALL_BUFF)
-    #     result.add_to_back(lp)
-    #     result.add(rp)
-    #     return result
-
-    def get_diffyq_set(self):
-        words = TextMobject(
-            "Differential\\\\equations"
-        )
-        words.scale(1.5)
-        words.set_color(BLUE)
-        lb = Brace(words, LEFT)
-        rb = Brace(words, RIGHT)
-        return VGroup(lb, words, rb)

from_3b1b/active/diffyq/part4/complex_functions.py

@@ -1,712 +0,0 @@
-from manimlib.imports import *
-
-
-class GeneralizeToComplexFunctions(Scene):
-    CONFIG = {
-        "axes_config": {
-            "x_min": 0,
-            "x_max": 10,
-            "x_axis_config": {
-                "stroke_width": 2,
-            },
-            "y_min": -2.5,
-            "y_max": 2.5,
-            "y_axis_config": {
-                "tick_frequency": 0.25,
-                "unit_size": 1.5,
-                "include_tip": False,
-                "stroke_width": 2,
-            },
-        },
-        "complex_plane_config": {
-            "axis_config": {
-                "unit_size": 2
-            }
-        },
-    }
-
-    def construct(self):
-        self.show_cosine_wave()
-        self.transition_to_complex_plane()
-        self.add_rotating_vectors_making_cos()
-
-    def show_cosine_wave(self):
-        axes = Axes(**self.axes_config)
-        axes.shift(2 * LEFT - axes.c2p(0, 0))
-        y_axis = axes.y_axis
-        y_labels = y_axis.get_number_mobjects(
-            *range(-2, 3),
-            number_config={"num_decimal_places": 1},
-        )
-
-        t_tracker = ValueTracker(0)
-        t_tracker.add_updater(lambda t, dt: t.increment_value(dt))
-        get_t = t_tracker.get_value
-
-        def func(x):
-            return 2 * np.cos(x)
-
-        cos_x_max = 20
-        cos_wave = axes.get_graph(func, x_max=cos_x_max)
-        cos_wave.set_color(YELLOW)
-        shown_cos_wave = cos_wave.copy()
-        shown_cos_wave.add_updater(
-            lambda m: m.pointwise_become_partial(
-                cos_wave, 0,
-                np.clip(get_t() / cos_x_max, 0, 1),
-            ),
-        )
-
-        dot = Dot()
-        dot.set_color(PINK)
-        dot.add_updater(lambda d: d.move_to(
-            y_axis.n2p(func(get_t())),
-        ))
-
-        h_line = always_redraw(lambda: Line(
-            dot.get_right(),
-            shown_cos_wave.get_end(),
-            stroke_width=1,
-        ))
-
-        real_words = TextMobject(
-            "Real number\\\\output"
-        )
-        real_words.to_edge(LEFT)
-        real_words.shift(2 * UP)
-        real_arrow = Arrow()
-        real_arrow.add_updater(
-            lambda m: m.put_start_and_end_on(
-                real_words.get_corner(DR),
-                dot.get_center(),
-            ).scale(0.9),
-        )
-
-        self.add(t_tracker)
-        self.add(axes)
-        self.add(y_labels)
-        self.add(shown_cos_wave)
-        self.add(dot)
-        self.add(h_line)
-
-        self.wait(2)
-        self.play(
-            FadeInFrom(real_words, RIGHT),
-            FadeIn(real_arrow),
-        )
-        self.wait(5)
-
-        y_axis.generate_target()
-        y_axis.target.rotate(-90 * DEGREES)
-        y_axis.target.center()
-        y_axis.target.scale(2 / 1.5)
-        y_labels.generate_target()
-        for label in y_labels.target:
-            label.next_to(
-                y_axis.target.n2p(label.get_value()),
-                DOWN, MED_SMALL_BUFF,
-            )
-        self.play(
-            FadeOut(shown_cos_wave),
-            FadeOut(axes.x_axis),
-            FadeOut(h_line),
-        )
-        self.play(
-            MoveToTarget(y_axis),
-            MoveToTarget(y_labels),
-            real_words.shift, 2 * RIGHT + UP,
-        )
-        self.wait()
-
-        self.y_axis = y_axis
-        self.y_labels = y_labels
-        self.real_words = real_words
-        self.real_arrow = real_arrow
-        self.dot = dot
-        self.t_tracker = t_tracker
-
-    def transition_to_complex_plane(self):
-        y_axis = self.y_axis
-        y_labels = self.y_labels
-
-        plane = self.get_complex_plane()
-        plane_words = plane.label
-
-        self.add(plane, *self.get_mobjects())
-        self.play(
-            FadeOut(y_labels),
-            FadeOut(y_axis),
-            ShowCreation(plane),
-        )
-        self.play(Write(plane_words))
-        self.wait()
-
-        self.plane = plane
-        self.plane_words = plane_words
-
-    def add_rotating_vectors_making_cos(self):
-        plane = self.plane
-        real_words = self.real_words
-        real_arrow = self.real_arrow
-        t_tracker = self.t_tracker
-        get_t = t_tracker.get_value
-
-        v1 = Vector(2 * RIGHT)
-        v2 = Vector(2 * RIGHT)
-        v1.set_color(BLUE)
-        v2.set_color(interpolate_color(GREY_BROWN, WHITE, 0.5))
-        v1.add_updater(
-            lambda v: v.set_angle(get_t())
-        )
-        v2.add_updater(
-            lambda v: v.set_angle(-get_t())
-        )
-        v1.add_updater(
-            lambda v: v.shift(plane.n2p(0) - v.get_start())
-        )
-        # Change?
-        v2.add_updater(
-            lambda v: v.shift(plane.n2p(0) - v.get_start())
-        )
-
-        ghost_v1 = v1.copy()
-        ghost_v1.set_opacity(0.5)
-        ghost_v1.add_updater(
-            lambda v: v.shift(
-                v2.get_end() - v.get_start()
-            )
-        )
-
-        ghost_v2 = v2.copy()
-        ghost_v2.set_opacity(0.5)
-        ghost_v2.add_updater(
-            lambda v: v.shift(
-                v1.get_end() - v.get_start()
-            )
-        )
-
-        circle = Circle(color=GREY_BROWN)
-        circle.set_stroke(width=1)
-        circle.set_width(2 * v1.get_length())
-        circle.move_to(plane.n2p(0))
-
-        formula = TexMobject(
-            # "\\cos(x) ="
-            # "{1 \\over 2}e^{ix} +"
-            # "{1 \\over 2}e^{-ix}",
-            "2\\cos(x) =",
-            "e^{ix}", "+", "e^{-ix}",
-            tex_to_color_map={
-                "e^{ix}": v1.get_color(),
-                "e^{-ix}": v2.get_color(),
-            }
-        )
-        formula.next_to(ORIGIN, UP, buff=0.75)
-        # formula.add_background_rectangle()
-        formula.set_stroke(BLACK, 3, background=True)
-        formula.to_edge(LEFT, buff=MED_SMALL_BUFF)
-        formula_brace = Brace(formula[1:], UP)
-        formula_words = formula_brace.get_text(
-            "Sum of\\\\rotations"
-        )
-        formula_words.set_stroke(BLACK, 3, background=True)
-
-        randy = Randolph()
-        randy.to_corner(DL)
-        randy.look_at(formula)
-
-        self.play(
-            FadeOut(real_words),
-            FadeOut(real_arrow),
-        )
-        self.play(
-            FadeIn(v1),
-            FadeIn(v2),
-            FadeIn(circle),
-            FadeIn(ghost_v1),
-            FadeIn(ghost_v2),
-        )
-        self.wait(3)
-        self.play(FadeInFromDown(formula))
-        self.play(
-            GrowFromCenter(formula_brace),
-            FadeIn(formula_words),
-        )
-        self.wait(2)
-        self.play(FadeIn(randy))
-        self.play(randy.change, "pleading")
-        self.play(Blink(randy))
-        self.wait()
-        self.play(randy.change, "confused")
-        self.play(Blink(randy))
-        self.wait()
-        self.play(FadeOut(randy))
-        self.wait(20)
-
-    #
-    def get_complex_plane(self):
-        plane = ComplexPlane(**self.complex_plane_config)
-        plane.add_coordinates()
-
-        plane.label = TextMobject("Complex plane")
-        plane.label.scale(1.5)
-        plane.label.to_corner(UR, buff=MED_SMALL_BUFF)
-        return plane
-
-
-class ClarifyInputAndOutput(GeneralizeToComplexFunctions):
-    CONFIG = {
-        "input_space_rect_config": {
-            "stroke_color": WHITE,
-            "stroke_width": 1,
-            "fill_color": DARKER_GREY,
-            "fill_opacity": 1,
-            "width": 6,
-            "height": 2,
-        },
-    }
-
-    def construct(self):
-        self.setup_plane()
-        self.setup_input_space()
-        self.setup_input_trackers()
-
-        self.describe_input()
-        self.describe_output()
-
-    def setup_plane(self):
-        plane = self.get_complex_plane()
-        plane.sublabel = TextMobject("(Output space)")
-        plane.sublabel.add_background_rectangle()
-        plane.sublabel.next_to(plane.label, DOWN)
-        self.add(plane, plane.label)
-        self.plane = plane
-
-    def setup_input_space(self):
-        rect = Rectangle(**self.input_space_rect_config)
-        rect.to_corner(UL, buff=SMALL_BUFF)
-
-        input_line = self.get_input_line(rect)
-        input_words = TextMobject("Input space")
-        input_words.next_to(
-            rect.get_bottom(), UP,
-            SMALL_BUFF,
-        )
-
-        self.add(rect)
-        self.add(input_line)
-
-        self.input_rect = rect
-        self.input_line = input_line
-        self.input_words = input_words
-
-    def setup_input_trackers(self):
-        plane = self.plane
-        input_line = self.input_line
-        input_tracker = ValueTracker(0)
-        get_input = input_tracker.get_value
-
-        input_dot = Dot()
-        input_dot.set_color(PINK)
-        f_always(
-            input_dot.move_to,
-            lambda: input_line.n2p(get_input())
-        )
-
-        input_decimal = DecimalNumber()
-        input_decimal.scale(0.7)
-        always(input_decimal.next_to, input_dot, UP)
-        f_always(input_decimal.set_value, get_input)
-
-        path = self.get_path()
-
-        def get_output_point():
-            return path.point_from_proportion(
-                get_input()
-            )
-
-        output_dot = Dot()
-        output_dot.match_style(input_dot)
-        f_always(output_dot.move_to, get_output_point)
-
-        output_vector = Vector()
-        output_vector.set_color(WHITE)
-        output_vector.add_updater(
-            lambda v: v.put_start_and_end_on(
-                plane.n2p(0),
-                get_output_point()
-            )
-        )
-
-        output_decimal = DecimalNumber()
-        output_decimal.scale(0.7)
-        always(output_decimal.next_to, output_dot, UR, SMALL_BUFF)
-        f_always(
-            output_decimal.set_value,
-            lambda: plane.p2n(get_output_point()),
-        )
-
-        self.input_tracker = input_tracker
-        self.input_dot = input_dot
-        self.input_decimal = input_decimal
-        self.path = path
-        self.output_dot = output_dot
-        self.output_vector = output_vector
-        self.output_decimal = output_decimal
-
-    def describe_input(self):
-        input_tracker = self.input_tracker
-
-        self.play(FadeInFrom(self.input_words, UP))
-        self.play(
-            FadeInFromLarge(self.input_dot),
-            FadeIn(self.input_decimal),
-        )
-        for value in 1, 0:
-            self.play(
-                input_tracker.set_value, value,
-                run_time=2
-            )
-        self.wait()
-
-    def describe_output(self):
-        path = self.path
-        output_dot = self.output_dot
-        output_decimal = self.output_decimal
-        input_dot = self.input_dot
-        input_tracker = self.input_tracker
-        plane = self.plane
-        real_line = plane.x_axis.copy()
-        real_line.set_stroke(RED, 4)
-        real_words = TextMobject("Real number line")
-        real_words.next_to(ORIGIN, UP)
-        real_words.to_edge(RIGHT)
-
-        traced_path = TracedPath(output_dot.get_center)
-        traced_path.match_style(path)
-
-        self.play(
-            ShowCreation(real_line),
-            FadeInFrom(real_words, DOWN)
-        )
-        self.play(
-            FadeOut(real_line),
-            FadeOut(real_words),
-        )
-        self.play(
-            FadeInFrom(plane.sublabel, UP)
-        )
-        self.play(
-            FadeIn(output_decimal),
-            TransformFromCopy(input_dot, output_dot),
-        )
-
-        kw = {
-            "run_time": 10,
-            "rate_func": lambda t: smooth(t, 1),
-        }
-        self.play(
-            ApplyMethod(input_tracker.set_value, 1, **kw),
-            ShowCreation(path.copy(), remover=True, **kw),
-        )
-        self.add(path)
-        self.add(output_dot)
-        self.wait()
-
-        # Flatten to 1d
-        real_function_word = TextMobject(
-            "Real-valued function"
-        )
-        real_function_word.next_to(ORIGIN, DOWN, MED_LARGE_BUFF)
-        path.generate_target()
-        path.target.stretch(0, 1)
-        path.target.move_to(plane.n2p(0))
-
-        self.play(
-            FadeIn(real_function_word),
-            MoveToTarget(path),
-        )
-        input_tracker.set_value(0)
-        self.play(
-            input_tracker.set_value, 1,
-            **kw
-        )
-
-    #
-    def get_input_line(self, input_rect):
-        input_line = UnitInterval()
-        input_line.move_to(input_rect)
-        input_line.shift(0.25 * UP)
-        input_line.set_width(
-            input_rect.get_width() - 1
-        )
-        input_line.add_numbers(0, 0.5, 1)
-        return input_line
-
-    def get_path(self):
-        # mob = SVGMobject("BatmanLogo")
-        mob = TexMobject("\\pi")
-        path = mob.family_members_with_points()[0]
-        path.set_height(3.5)
-        path.move_to(2 * DOWN, DOWN)
-        path.set_stroke(YELLOW, 2)
-        path.set_fill(opacity=0)
-        return path
-
-
-class GraphForFlattenedPi(ClarifyInputAndOutput):
-    CONFIG = {
-        "camera_config": {"background_color": DARKER_GREY},
-    }
-
-    def construct(self):
-        self.setup_plane()
-        plane = self.plane
-        self.remove(plane, plane.label)
-
-        path = self.get_path()
-
-        axes = Axes(
-            x_min=0,
-            x_max=1,
-            x_axis_config={
-                "unit_size": 7,
-                "include_tip": False,
-                "tick_frequency": 0.1,
-            },
-            y_min=-1.5,
-            y_max=1.5,
-            y_axis_config={
-                "include_tip": False,
-                "unit_size": 2.5,
-                "tick_frequency": 0.5,
-            },
-        )
-        axes.set_width(FRAME_WIDTH - 1)
-        axes.set_height(FRAME_HEIGHT - 1, stretch=True)
-        axes.center()
-
-        axes.x_axis.add_numbers(
-            0.5, 1.0,
-            number_config={"num_decimal_places": 1},
-        )
-        axes.y_axis.add_numbers(
-            -1.0, 1.0,
-            number_config={"num_decimal_places": 1},
-        )
-
-        def func(t):
-            return plane.x_axis.p2n(
-                path.point_from_proportion(t)
-            )
-
-        graph = axes.get_graph(func)
-        graph.set_color(PINK)
-
-        v_line = always_redraw(lambda: Line(
-            axes.x_axis.n2p(axes.x_axis.p2n(graph.get_end())),
-            graph.get_end(),
-            stroke_width=1,
-        ))
-
-        self.add(axes)
-        self.add(v_line)
-
-        kw = {
-            "run_time": 10,
-            "rate_func": lambda t: smooth(t, 1),
-        }
-        self.play(ShowCreation(graph, **kw))
-        self.wait()
-
-
-class SimpleComplexExponentExample(ClarifyInputAndOutput):
-    CONFIG = {
-        "input_space_rect_config": {
-            "width": 14,
-            "height": 1.5,
-        },
-        "input_line_config": {
-            "unit_size": 0.5,
-            "x_min": 0,
-            "x_max": 25,
-            "stroke_width": 2,
-        },
-        "input_numbers": range(0, 30, 5),
-        "input_tex_args": ["t", "="],
-    }
-
-    def construct(self):
-        self.setup_plane()
-        self.setup_input_space()
-        self.setup_input_trackers()
-        self.setup_output_trackers()
-
-        # Testing
-        time = self.input_line.x_max
-        self.play(
-            self.input_tracker.set_value, time,
-            run_time=time,
-            rate_func=linear,
-        )
-
-    def setup_plane(self):
-        plane = ComplexPlane()
-        plane.scale(2)
-        plane.add_coordinates()
-        plane.shift(DOWN)
-        self.plane = plane
-        self.add(plane)
-
-    def setup_input_trackers(self):
-        input_line = self.input_line
-        input_tracker = ValueTracker(0)
-        get_input = input_tracker.get_value
-
-        input_tip = ArrowTip(start_angle=-TAU / 4)
-        input_tip.scale(0.5)
-        input_tip.set_color(PINK)
-        f_always(
-            input_tip.move_to,
-            lambda: input_line.n2p(get_input()),
-            lambda: DOWN,
-        )
-
-        input_label = VGroup(
-            TexMobject(*self.input_tex_args),
-            DecimalNumber(),
-        )
-        input_label[0].set_color_by_tex("t", PINK)
-        input_label.scale(0.7)
-        input_label.add_updater(
-            lambda m: m.arrange(RIGHT, buff=SMALL_BUFF)
-        )
-        input_label.add_updater(
-            lambda m: m[1].set_value(get_input())
-        )
-        input_label.add_updater(
-            lambda m: m.next_to(input_tip, UP, SMALL_BUFF)
-        )
-
-        self.input_tracker = input_tracker
-        self.input_tip = input_tip
-        self.input_label = input_label
-
-        self.add(input_tip, input_label)
-
-    def setup_output_trackers(self):
-        plane = self.plane
-        get_input = self.input_tracker.get_value
-
-        def get_output():
-            return np.exp(complex(0, get_input()))
-
-        def get_output_point():
-            return plane.n2p(get_output())
-
-        output_label, static_output_label = [
-            TexMobject(
-                "e^{i t}" + s,
-                tex_to_color_map={"t": PINK},
-                background_stroke_width=3,
-            )
-            for s in ["", "\\approx"]
-        ]
-        output_label.scale(1.2)
-        output_label.add_updater(
-            lambda m: m.shift(
-                -m.get_bottom() +
-                get_output_point() +
-                rotate_vector(
-                    0.35 * RIGHT,
-                    get_input(),
-                )
-            )
-        )
-
-        output_vector = Vector()
-        output_vector.set_opacity(0.75)
-        output_vector.add_updater(
-            lambda m: m.put_start_and_end_on(
-                plane.n2p(0), get_output_point(),
-            )
-        )
-
-        t_max = 40
-        full_output_path = ParametricFunction(
-            lambda t: plane.n2p(np.exp(complex(0, t))),
-            t_min=0,
-            t_max=t_max
-        )
-        output_path = VMobject()
-        output_path.set_stroke(YELLOW, 2)
-        output_path.add_updater(
-            lambda m: m.pointwise_become_partial(
-                full_output_path,
-                0, get_input() / t_max,
-            )
-        )
-
-        static_output_label.next_to(plane.c2p(1, 1), UR)
-        output_decimal = DecimalNumber(
-            include_sign=True,
-        )
-        output_decimal.scale(0.8)
-        output_decimal.set_stroke(BLACK, 3, background=True)
-        output_decimal.add_updater(
-            lambda m: m.set_value(get_output())
-        )
-        output_decimal.add_updater(
-            lambda m: m.next_to(
-                static_output_label,
-                RIGHT, 2 * SMALL_BUFF,
-                aligned_edge=DOWN,
-            )
-        )
-
-        self.add(output_path)
-        self.add(output_vector)
-        self.add(output_label)
-        self.add(static_output_label)
-        self.add(BackgroundRectangle(output_decimal))
-        self.add(output_decimal)
-
-    #
-    def get_input_line(self, input_rect):
-        input_line = NumberLine(**self.input_line_config)
-        input_line.move_to(input_rect)
-        input_line.set_width(
-            input_rect.get_width() - 1.5,
-            stretch=True,
-        )
-        input_line.add_numbers(*self.input_numbers)
-        return input_line
-
-
-class TRangingFrom0To1(SimpleComplexExponentExample):
-    CONFIG = {
-        "input_space_rect_config": {
-            "width": 6,
-            "height": 2,
-        },
-    }
-
-    def construct(self):
-        self.setup_input_space()
-        self.setup_input_trackers()
-
-        self.play(
-            self.input_tracker.set_value, 1,
-            run_time=10,
-            rate_func=linear
-        )
-
-    def get_input_line(self, rect):
-        result = ClarifyInputAndOutput.get_input_line(self, rect)
-        result.stretch(0.9, 0)
-        result.set_stroke(width=2)
-        for sm in result.get_family():
-            if isinstance(sm, DecimalNumber):
-                sm.stretch(1 / 0.9, 0)
-                sm.set_stroke(width=0)
-        return result

from_3b1b/active/diffyq/part4/long_fourier_scenes.py

@@ -1,242 +0,0 @@
-from manimlib.imports import *
-
-from active_projects.diffyq.part4.fourier_series_scenes import ComplexFourierSeriesExample
-from manimlib.once_useful_constructs.fractals import HilbertCurve
-
-
-class FourierSeriesExampleWithRectForZoom(ComplexFourierSeriesExample):
-    CONFIG = {
-        "n_vectors": 100,
-        "slow_factor": 0.01,
-        "rect_scale_factor": 0.1,
-        "start_drawn": True,
-        "drawing_height": 7,
-        "rect_stroke_width": 1,
-    }
-
-    def construct(self):
-        self.add_vectors_circles_path()
-        self.circles.set_stroke(opacity=0.5)
-        rect = self.rect = self.get_rect()
-        rect.set_height(self.rect_scale_factor * FRAME_HEIGHT)
-        rect.add_updater(lambda m: m.move_to(
-            self.get_rect_center()
-        ))
-        self.add(rect)
-        self.run_one_cycle()
-
-    def get_rect_center(self):
-        return center_of_mass([
-            v.get_end()
-            for v in self.vectors
-        ])
-
-    def get_rect(self):
-        return ScreenRectangle(
-            color=BLUE,
-            stroke_width=self.rect_stroke_width,
-        )
-
-
-class ZoomedInFourierSeriesExample(FourierSeriesExampleWithRectForZoom, MovingCameraScene):
-    CONFIG = {
-        "vector_config": {
-            "max_tip_length_to_length_ratio": 0.15,
-            "tip_length": 0.05,
-        },
-        "parametric_function_step_size": 0.001,
-    }
-
-    def setup(self):
-        ComplexFourierSeriesExample.setup(self)
-        MovingCameraScene.setup(self)
-
-    def get_rect(self):
-        return self.camera_frame
-
-    def add_vectors_circles_path(self):
-        super().add_vectors_circles_path()
-        for v in self.vectors:
-            if v.get_stroke_width() < 1:
-                v.set_stroke(width=1)
-
-
-class ZoomedInFourierSeriesExample100x(ZoomedInFourierSeriesExample):
-    CONFIG = {
-        "vector_config": {
-            "max_tip_length_to_length_ratio": 0.15 * 0.4,
-            "tip_length": 0.05 * 0.2,
-            "max_stroke_width_to_length_ratio": 80,
-            "stroke_width": 3,
-        },
-        "max_circle_stroke_width": 0.5,
-        "rect_scale_factor": 0.01,
-        # "parametric_function_step_size": 0.01,
-    }
-
-    def get_rect_center(self):
-        return self.vectors[-1].get_end()
-
-    # def get_drawn_path(self, vectors, stroke_width=2, **kwargs):
-    #     return self.get_path_end(vectors, stroke_width, **kwargs)
-
-
-class TrebleClefFourierSeriesExampleWithRectForZoom(FourierSeriesExampleWithRectForZoom):
-    CONFIG = {
-        "file_name": "TrebleClef",
-        "drawn_path_stroke_width": 10,
-    }
-
-
-class TrebleClefZoomedInFourierSeriesExample(ZoomedInFourierSeriesExample):
-    CONFIG = {
-        "file_name": "TrebleClef",
-    }
-
-
-class NailAndGearFourierSeriesExampleWithRectForZoom(FourierSeriesExampleWithRectForZoom):
-    CONFIG = {
-        "file_name": "Nail_And_Gear",
-        "n_vectors": 200,
-        "drawn_path_color": "#39FF14",
-    }
-
-
-class NailAndGearZoomedInFourierSeriesExample(ZoomedInFourierSeriesExample):
-    CONFIG = {
-        "file_name": "Nail_And_Gear",
-        "n_vectors": 200,
-        "drawn_path_color": "#39FF14",
-    }
-
-
-class SigmaFourierSeriesExampleWithRectForZoom(FourierSeriesExampleWithRectForZoom):
-    CONFIG = {
-        "n_vectors": 200,
-        "drawn_path_color": PINK,
-        "rect_stroke_width": 0,
-    }
-
-    def get_shape(self):
-        return TexMobject("\\Sigma")
-
-
-class SigmaZoomedInFourierSeriesExample(SigmaFourierSeriesExampleWithRectForZoom, ZoomedInFourierSeriesExample):
-    pass
-
-
-class FourierOfFourier(FourierSeriesExampleWithRectForZoom):
-    CONFIG = {
-        "file_name": "FourierOneLine",
-        "n_vectors": 300,
-        "rect_stroke_width": 1,
-    }
-
-
-class FourierOfFourierZoomedIn(ZoomedInFourierSeriesExample):
-    CONFIG = {
-        "file_name": "FourierOneLine",
-        "max_circle_stroke_width": 0.3,
-        "n_vectors": 300,
-    }
-
-
-class FourierOfFourier100xZoom(ZoomedInFourierSeriesExample100x):
-    CONFIG = {
-        "file_name": "FourierOneLine",
-        "max_circle_stroke_width": 0.3,
-        "n_vectors": 300,
-        "slow_factor": 0.001,
-    }
-
-    def run_one_cycle(self):
-        self.vector_clock.set_value(0.3)
-        self.wait(40)
-
-
-class FourierOfHilbert(FourierSeriesExampleWithRectForZoom):
-    CONFIG = {
-        "n_vectors": 300,
-        "rect_stroke_width": 1,
-        "drawn_path_stroke_width": 4,
-        "drawn_path_color": BLUE,
-    }
-
-    def get_path(self):
-        path = HilbertCurve(order=5)
-        path.set_height(self.drawing_height)
-        path.to_edge(DOWN)
-        combined_path = VMobject()
-        for sm in path.family_members_with_points():
-            combined_path.append_vectorized_mobject(sm)
-        start = combined_path.get_start()
-        end = combined_path.get_end()
-        points = [
-            interpolate(end, start, alpha)
-            for alpha in np.linspace(0, 1, 10)
-        ]
-        for point in points:
-            combined_path.add_line_to(point)
-
-        combined_path.set_stroke(width=0)
-        return combined_path
-
-
-class FourierOfHilbertZoomedIn(FourierOfHilbert, ZoomedInFourierSeriesExample):
-    pass
-
-
-class FourierOfBritain(FourierSeriesExampleWithRectForZoom):
-    CONFIG = {
-        "file_name": "Britain",
-        "n_vectors": 500,
-        "drawn_path_color": RED,
-    }
-
-
-class FourierOfBritainZoomedIn(FourierOfBritain, ZoomedInFourierSeriesExample):
-    pass
-
-
-class FourierOfSeattle(FourierSeriesExampleWithRectForZoom):
-    CONFIG = {
-        "file_name": "SeattleSkyline",
-        "drawing_height": 7,
-        "n_vectors": 400,
-        "drawn_path_color": TEAL,
-        "drawn_path_stroke_width": 5,
-    }
-
-
-class FourierOfSeattleZoomedIn(ZoomedInFourierSeriesExample):
-    CONFIG = {
-        "file_name": "SeattleSkyline",
-        "drawing_height": 7,
-        "n_vectors": 400,
-        "drawn_path_color": TEAL,
-        "drawn_path_stroke_width": 5,
-        "max_circle_stroke_width": 0.3,
-    }
-
-
-class VideoWrapper(Scene):
-    def construct(self):
-        fade_rect = FullScreenFadeRectangle()
-        fade_rect.set_fill(DARK_GREY, 1)
-        screen_rect = ScreenRectangle()
-        screen_rect.set_height(4)
-        screen_rect.set_fill(BLACK, 1)
-        screen_rect.set_stroke(width=0)
-
-        boundary = AnimatedBoundary(screen_rect)
-
-        title = TextMobject("Learn the math")
-        title.scale(1.5)
-        title.next_to(screen_rect, UP)
-
-        self.add(fade_rect)
-        self.add(screen_rect)
-        self.add(boundary)
-
-        self.play(FadeInFromDown(title))
-        self.wait(19)

from_3b1b/active/diffyq/part4/pi_creature_scenes.py

@@ -1,235 +0,0 @@
-from manimlib.imports import *
-
-
-class WhyWouldYouCare(TeacherStudentsScene):
-    def construct(self):
-        self.student_says(
-            "Who cares!",
-            target_mode="sassy",
-            student_index=2,
-            added_anims=[self.teacher.change, "guilty"],
-        )
-        self.wait()
-        self.play(
-            RemovePiCreatureBubble(self.students[2]),
-            self.teacher.change, "raise_right_hand",
-            self.get_student_changes(
-                "pondering", "erm", "thinking",
-                look_at_arg=self.screen,
-            )
-        )
-        self.look_at(self.screen)
-        self.wait(5)
-
-
-class SolveForWavesNothingElse(TeacherStudentsScene):
-    def construct(self):
-        self.student_says(
-            "Sure, we can\\\\solve it for\\\\sums of waves...",
-            target_mode="sassy",
-            student_index=2,
-            added_anims=[self.teacher.change, "guilty"]
-        )
-        self.change_student_modes("pondering", "pondering", "sassy")
-        self.look_at(self.screen)
-        self.wait(4)
-        self.student_says(
-            "But nothing else!",
-            target_mode="angry",
-        )
-        self.change_student_modes(
-            "concerned_musician",
-            "concerned_musician",
-            "angry",
-        )
-        self.wait(5)
-
-
-class HangOnThere(TeacherStudentsScene):
-    def construct(self):
-        student = self.students[2]
-
-        axes1 = Axes(
-            x_min=0,
-            x_max=1,
-            y_min=-1.5,
-            y_max=1.5,
-            x_axis_config={
-                "tick_frequency": 0.25,
-                "include_tip": False,
-                "unit_size": 3,
-            },
-            y_axis_config={
-                "tick_frequency": 0.5,
-                "include_tip": False,
-            },
-        )
-        axes1.set_stroke(width=2)
-        axes2 = axes1.deepcopy()
-        neq = TexMobject("\\neq")
-        neq.scale(2)
-
-        group = VGroup(axes1, neq, axes2)
-        group.arrange(RIGHT)
-        group.set_height(4)
-        group.next_to(
-            student.get_corner(UL), UP,
-            buff=LARGE_BUFF,
-        )
-
-        step_graph = axes1.get_graph(
-            lambda x: (1 if x < 0.5 else -1),
-            discontinuities=[0.5],
-        )
-        step_graph.set_color(YELLOW)
-        wave_graphs = VGroup(*[
-            axes2.get_graph(
-                lambda x: (4 / PI) * np.sum([
-                    (u / n) * np.cos(n * PI * x)
-                    for u, n in zip(
-                        it.cycle([1, -1]),
-                        range(1, max_n, 2),
-                    )
-                ]),
-            )
-            for max_n in range(3, 103, 2)
-        ])
-        wave_graphs.set_stroke(width=3)
-        wave_graphs.set_color_by_gradient(WHITE, PINK)
-        last_wave_graph = wave_graphs[-1]
-        last_wave_graph.set_stroke(PINK, 2)
-        wave_graphs.remove(last_wave_graph)
-        # wave_graphs[-1].set_stroke(width=3)
-        # wave_graphs[-1].set_stroke(BLACK, 5, background=True)
-        group.add(step_graph)
-
-        self.student_says(
-            "Hang on\\\\hang on\\\\hang on...",
-            target_mode="surprised",
-            content_introduction_class=FadeIn,
-            student_index=2,
-            added_anims=[
-                self.teacher.change, "guilty"
-            ],
-            run_time=1,
-        )
-        self.wait()
-        self.play(
-            RemovePiCreatureBubble(
-                student,
-                target_mode="raise_left_hand",
-                look_at_arg=group,
-            ),
-            FadeInFromDown(group),
-        )
-
-        last_wg = VectorizedPoint()
-        n_first_fades = 4
-        for wg in wave_graphs[:n_first_fades]:
-            self.play(
-                last_wg.set_stroke, {"width": 0.1},
-                FadeIn(wg),
-            )
-            last_wg = wg
-        self.play(
-            LaggedStart(
-                *[
-                    UpdateFromAlphaFunc(
-                        wg,
-                        lambda m, a: m.set_stroke(
-                            width=(3 * there_and_back(a) + 0.1 * a)
-                        ),
-                    )
-                    for wg in wave_graphs[n_first_fades:]
-                ],
-                run_time=5,
-                lag_ratio=0.2,
-            ),
-            ApplyMethod(
-                last_wg.set_stroke, {"width": 0.1},
-                run_time=0.25,
-            ),
-            FadeIn(
-                last_wave_graph,
-                rate_func=squish_rate_func(smooth, 0.9, 1),
-                run_time=5,
-            ),
-            self.teacher.change, "thinking",
-        )
-        self.change_student_modes(
-            "confused", "confused", "angry"
-        )
-        self.wait(3)
-
-
-class YouSaidThisWasEasier(TeacherStudentsScene):
-    def construct(self):
-        self.change_all_student_modes(
-            "confused", look_at_arg=self.screen,
-        )
-        self.student_says(
-            "I'm sorry, you said\\\\this was easier?",
-            target_mode="sassy"
-        )
-        self.play(self.teacher.change, "guilty")
-        self.wait(3)
-        self.teacher_says(
-            "Bear with\\\\me",
-            bubble_kwargs={"height": 3, "width": 3},
-        )
-        self.look_at(self.screen)
-        self.wait(3)
-
-
-class LooseWithLanguage(TeacherStudentsScene):
-    def construct(self):
-        terms = VGroup(
-            TextMobject("``Complex number''"),
-            TextMobject("``Vector''"),
-        )
-        colors = [YELLOW, BLUE]
-        for term, color in zip(terms, colors):
-            term.set_color(color)
-
-        terms.scale(1.5)
-        terms.arrange(DOWN, buff=LARGE_BUFF)
-        terms.to_edge(UP)
-        terms.match_x(self.students)
-
-        self.teacher_says(
-            "Loose with\\\\language",
-            bubble_kwargs={"width": 3, "height": 3},
-            run_time=2,
-        )
-        self.play(
-            FadeInFrom(terms[1], DOWN),
-            self.get_student_changes(
-                "thinking", "pondering", "erm",
-                look_at_arg=terms,
-            )
-        )
-        self.play(FadeInFromDown(terms[0]))
-        self.wait()
-        self.play(Swap(*terms))
-        self.wait(3)
-
-
-class FormulaOutOfContext(TeacherStudentsScene):
-    def construct(self):
-        formula = TexMobject(
-            "c_{n} = \\int_0^1 e^{-2\\pi i {n} {t}}f({t}){dt}",
-            tex_to_color_map={
-                "{n}": YELLOW,
-                "{t}": PINK,
-            }
-        )
-        formula.scale(1.5)
-        formula.next_to(self.students, UP, LARGE_BUFF)
-
-        self.add(formula)
-        self.change_all_student_modes(
-            "horrified",
-            look_at_arg=formula,
-        )
-        self.play(self.teacher.change, "tease")
-        self.wait(3)