SciPy 2020 Tutorial Proposal - sympy/sympy GitHub Wiki

SciPy 2020 Tutorial Proposal

If you are interested in co-submitting, please contact Aaron Meurer ([email protected]). You will need to sign up on the submission website (go to https://www.scipy2020.scipy.org/tutorials and click "submit your tutorial", then create an account on EasyChair).

Questions for other submitters

  • Is 10 minute breaks every hour enough?

Submission Instructions

(This is taken from the submission site)

Proposals must be submitted by February 11, 2020.

Tutorials should be focused on covering a well-defined topic in a hands-on manner. We want to see attendees coding! We encourage submissions to be designed to allow at least 50% of the time for hands-on exercises even if this means the subject matter needs to be limited. Tutorials will be 4 hours in duration. In your tutorial application, you can indicate what prerequisite skills and knowledge will be needed for your tutorial, and the approximate expected level of knowledge of your students (i.e., beginner, intermediate, advanced).

For examples of content and format, you can refer to tutorials from past SciPy tutorial sessions (SciPy 2019, SciPy 2018, SciPy2017)

We are looking for interesting techniques or packages, helping new or advanced Python programmers develop better or faster scientific applications. Authors of exemplary submissions from previous years have generously agreed to share their proposals to help new instructors: https://github.com/scipy-conference/scipy-conference/tree/master/data/tutorial_submissions.

Additional information may be found at https://www.scipy2020.scipy.org/tutorials.

Proposal

Note that all forms should be plain text. Do not use Markdown formatting.

Title

Symbolic Computation with Python using SymPy

Abstract

SymPy is a Python library for symbolic mathematics. This tutorial will introduce SymPy to a beginner audience. It will cover an introduction to symbolic computing, basic symbolic operations, simplification, calculus, matrices, advanced expression manipulation, code generation, and select advanced topics. The tutorial does not have any prerequisites beyond knowledge of Python and basic freshman level mathematics. It will be presented with Jupyter notebooks with regular exercises for the attendees. After attending this tutorial, attendees will be able to start using SymPy to solve their own problems.

Keywords

Type a list of keywords (also known as key phrases or key terms), one per line to characterize your submission. You should specify at least three keywords.

SymPy

Symbolic Mathematics

Python

Tutorial Description

A description of the tutorial, suitable for posting on the SciPy website for attendees to view. It should include the target audience, the expected level of knowledge prior to the class, and the goals of the class.

SymPy is a pure Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. SymPy is written entirely in Python.

SymPy can be used in a wide array of applications. This includes basic usage as an interactive calculator, symbolically modeling problems in physics and engineering, generating fast numeric code, and use in a Python library representing custom symbolic objects. Anyone interested learning how to get started using SymPy for any such applications should attend this tutorial.

This tutorial is a beginner level tutorial and only requires knowledge of how to use Python. Knowledge of mathematics up to basic calculus is recommended. More advanced mathematical topics will be explained as part of the tutorial. Knowledge of other Python libraries such as NumPy is NOT required.

This tutorial will cover the basics of how to use SymPy, and will also touch on some advanced topics. We will start by discussing the basics of how to build mathematical expressions with SymPy and manipulate them. We will look at how to avoid some of the more common pitfalls and gotchas when using the SymPy. We will then move onto the most common functions in SymPy such as simplification functions, solvers, functions for doing operations from calculus such as differentiation and integration, and matrices. Finally, as time permits, we will look into more advanced topics, such as code generation, extending SymPy, interfacing with other libraries such as NumPy, and additional SymPy submodules.

After attending this tutorial, attendees will be able to start using SymPy to solve their own problems. They will also be armed with the knowledge of how to discover additional more specific functionality in SymPy that may be required for their particular use-case.

Tutorial Outline

A more detailed outline of the tutorial content, including the duration of each part and exercise sessions. Please include a description of how you plan to make the tutorial hands-on.

We will expect tutorial attendees to have the tutorial materials installed on their computers prior to the tutorial. This way we will not waste time in the beginning getting things installed. The tutorial will also be available as a Binder for those that do not wish to install things locally.

All tutorial materials will be Jupyter notebooks. For each topic discussed below (except for the presentation), we will demonstrate the feature, then the attendees will complete short exercises in the accompanying notebook. We will aim for each individual exercise to be completable quickly, so that we can have a fast turnaround time. We will encourage attendees to work with each other and to ask questions to the instructors as they work. Some topics will also include optional advanced exercises for the students that finish the easier exercises more quickly.

Introduction to SymPy (presentation) (10 min.)

This will be a short presentation introducing the tutorial presenters, SymPy, and the SymPy community. This presentation will also give an opportunity for helpers to assist anyone who has had difficulty installing SymPy or loading the tutorial materials on their computer.

Introduction to Symbolic Computation (20 min.)

We will introduce the basics of symbolic computation with SymPy. Topics will include: how to create expressions, avoiding common gotchas and pitfalls, using SymPy in the Jupyter notebook, and pretty printing SymPy expressions.

Basic operations (20 min.)

More basic operations for expression manipulation. Topics will include substitution, numeric evaluation, and parsing strings into SymPy expressions.

Break (10 min.)

Simplification (25 min.)

This section will go over the most important ways to simplify expressions in SymPy. Topics will include simplification functions for polynomials, rational functions, powers, trigonometric functions, exponentials and logarithms, special functions, and advanced simplification techniques.

Calculus (25 min.)

This section will go over how to use SymPy to solve the most basic operations in calculus. Topics will include equation solving, derivatives, integrals, limits, series expansions, and differential equations.

Break (10 min.)

Matrices (25 min.)

This section will cover the basics of using matrices in SymPy. Topics will include, basic matrix operations, determinants, eigenvalues and eigenvectors, and matrix expressions.

Advanced expression manipulation (25 min.)

This section will go into more details about how to do advanced expression manipulation. This section will teach how SymPy expression trees work, and teach the basic expression manipulation building blocks for writing arbitrary algorithms that manipulates SymPy expressions.

Break (10 min.)

Code Generation (30 min.)

This section will go over the basics of how to use SymPy to generate fast code. Topics will include interfacing SymPy with NumPy via lambdify and generating code for C, Fortran, and other languages. We have given a whole tutorial on this topic in the past (SciPy 2017, see https://www.sympy.org/scipy-2017-codegen-tutorial/). As this section is only 30 minutes, this will be a very condensed version covering only the basic topics, with pointers to resources if attendees are interested in learning more.

Advanced Topics (30 min.)

At this point, if the tutorial attendees have any additional topics in SymPy that they would like to learn about, the presenters can demonstrate them live. SymPy has dozens of submodules and this tutorial only covers the very surface of what is possible. We have done a similar thing in past introductory tutorials and have had good experience with it. If there are no requests from the attendees, the presenters will choose some of their favorite parts of SymPy to demonstrate.

Additional Tutorial Information

If available, the tutorial notes, slides, exercise files, and IPython notebooks, even if they are preliminary.

Tutorial materials will be at https://github.com/sympy/scipy-2020-tutorial

Certain materials may be based on materials from the 2016 tutorial. https://github.com/sympy/scipy-2016-tutorial However, we anticipate that many materials will be largely rewritten, as we are using a slightly different tutorial outline this year. We will also use the student feedback from previous years in guiding which parts should be presented differently.

Some parts of the section on code generation may be based on the materials from the SciPy 2017 SymPy code generation tutorial. https://github.com/sympy/scipy-2017-codegen-tutorial As noted above, this section of tutorial will only be able cover the very basic topics.

Tutorial Prerequisites

(optional)

A list of prerequisite skills expected of attendees, so that participants can chose level appropriate tutorials.

This tutorial is a beginner level tutorial and only requires knowledge of how to use Python. Knowledge of mathematics up to basic calculus is recommended. More advanced mathematical topics will be explained as part of the tutorial. Knowledge of other Python libraries such as NumPy is NOT required. Basic knowledge of how to execute code in the Jupyter notebook is required for the tutorial exercises.

Please indicate the appropriate level of the attendees' Python knowledge.

Please note this reflects the attendees' Python programming level only, not the attendees' level of understanding of the topic.

(Multiple choice)

  • Beginner

  • Intermediate

  • Advanced

Instructor Bio(s)

A short bio of the presenter or team members, containing a description of past experiences as a trainer/teacher/speaker, and (ideally) links to videos of these experiences if available.

Paper (optional)

Upload your paper (optional). The paper must be in PDF format (file extension .pdf)