Syllabus#
Course Information#
Instructor(s): Michael McNeil Forbes
m.forbes+581@wsu.eduCourse Assistants:
Office: Webster 947F
Office Hours: F2-4pm in Webster 1243, MW4pm (after class), or by appointment.
Course Homepage: https://schedules.wsu.edu/sectionInfo/prefix=Phys&term=Fall&year=2025&course=581
Class Number: 581
Title: Phys 581: Compute Anything – Effective Scientific Computing
Credits: 3
Recommended Preparation: Strong background in calculus, real and complex analysis, linear algebra, familiarity with differential equations, and basic programming skills.
Meeting Time and Location: MW, 2:10pm - 4pm, Webster 941, Washington State University (WSU), Pullman, WA
Grading: Grade based on assignments, and project.
Prerequisites and Resources#
There are no formal prerequisites for the course, but I will expect you to be comfortable with the material discussed in the Prerequisites and Resources section, which contains links to additional resources should you need to refresh your knowledge.
Generally, I will expect familiarity with the following:
- Domain Specific Preparation:
The most important prerequisite is the ability to communicate about and formulate complex problems in your field of study that would benefit from the techniques covered in this course. Students will expected to actively engage with the techniques taught in this course, apply them to relevant problems in their domain of expertise, and to communicate about the efficacy to the class.
- Linear Algebra
Properties of Linear Operators (Self-Adjoint, Hermitian, Unitary, etc.), Matrix Factorization including the Singular Value Decomposition, Bases and Orthogonalization via Gram-Schmidt.
- Real and Complex Analysis
Topology (notions of continuity), Calculus, Banach spaces (e.g. conditions for the existence of extrema), Fourier Analysis, Contour Integration, Conformal Maps.
- Differential Equations
Formulation of differential equations, existence of solutions and boundary value requirements, Sturm-Liouville Theory.
- Programming Skills
There are some specific skills you will need for this course, including basic programming skills, distributed version control, how to connect remotely to computers etc. with SSH. We will use the CoCalc platform so you do not need to install any of the software on your computer. See the Prerequisites and Resources section for details and learning resources.
Textbooks and Resources#
 |
 |
 |
There is no formal textbook, but the following will be useful. These are either available electronically from the WSU Library, or on reserve:
- [Thomas and Hunt, 2019]
D. Thomas and A. Hunt: “The Pragmatic Programmer” (2019). Many of the core concepts of this course follow the principles laid out in this textbook, which espouses concepts like DRY (Don’t repeat yourself), Tracer Bullets, MVP (Minimum Viable Product) etc. Although expressed in terms of software development, many of these principles can help you improve your research. We will start each class discussing a topic from this book, as listed in the Course Timeline.
- [Gezerlis, 2020], [Gezerlis, 2023]
A. Gezerlis: “Numerical Methods in Physics with Python” (2023). This covers many useful algorithms with a focus on implementing them from scratch rather than using them as black-box routines. The 2nd edition has a few extra useful algorithms.
- [VanderPlas, 2016]
J. VanderPlas: “Python Data Science Handbook” (2016). More focused on data analysis, but Jake provides a very good description of techniques like plotting and animation. I have learned many of my skills from him and his blog Pythonic Perambulations.
- [Graham et al., 1994]
R.L. Graham, D.E. Knuth, and O. Patashnik: “Concrete Mathematics: A Foundation for Computer Science” (1994). A fabulous resource for discrete mathematics. This book systematically develops calculus for finite difference operators. If you need to know the analytic form for a series, this is the place to look.
- [Press et al., 2007]
Numerical Recipes: The Art of Scientific Computation is somewhat of a bible for scientific computing, and provides a rather complete reference of useful algorithms. You should be able to read any of the sections in this book as needed, and implement your own solution based on the content. Note: I do not personally use any of their actual code, but find the references and descriptions invaluable to be able to write my own solutions.
Additional readings will be assigned as needed. See References for details and additional resources.
Student Learning Outcomes#
The main objective of this course is for students to be able to effectively use numerical techniques to solve complex problems following principles of good software engineering and reproducible computing.
Reproducible Computing: Write and communicate computational results in a way that allows one to reproduce these results in the future, possibly on different computing platforms.
Problem Assessment: Be able to assess complex problems to determine if computational techniques will contribute to their solutions.
Choice of Algorithm/Technique: Be able to identify which algorithms are appropriate for solving the computational problems.
Implementation: Be able to implement the chosen algorithm.
Convergence and Performance Analysis: Be able to quantify and understand the convergence and performance of the algorithm being used.
Solution Assessment: Be able to assess the validity of the solution. For example, to quantify the uncertainties associated with the results, accounting for the accumulation of round-off, truncation, and discretization errors, with an understanding of the conditioning of both the problem and the algorithm.
Communicate and Defend the Solution: Communicate the results with peers, defending the approximations made, the accuracy of the techniques used, and the assessment of the solutions. Demonstrate insight into the nature of the solutions, making appropriate generalizations, and providing intuitive descriptions of the quantitative behavior found from solving the problem.
These learning outcomes will be assessed through the assignments as follows:
By maintaining a code repository subject to automated testing, students will have to master all skills needed for reproducible computing (1).
Through the successful completion of their assignments, students will demonstrate the ability to choose a technique (3) and implement it (4).
Class assignments will test both accuracy and performance of the code. Passing the associated tests will require that students have understood the convergence and performance properties of there code (5).
Code coverage will ensure that students implement tests for their code, assessing their solutions (6).
Through code reviews and documentation, students will be required to communicate and defend their solutions (7).
Course Timeline#
Date |
Topics |
|
|---|---|---|
Week 1: |
1: It’s Your Life |
CoCalc, General programming: Loops, Conditionals, Functions, Abstract Data Types (Queue, Priority Queue, Searching, and Sorting). |
Week 2: |
5: Good-Enough Software |
Survey, Recursion, Printing, Arrays, Plotting, Data, Floating Point Numbers, Finite difference derivatives, Round-off errors vs. truncation error |
Week 3: |
9: DRY - The Evils of Duplication |
Floating Point Numbers, Finite difference derivatives, Round-off errors vs. truncation error |
Week 4: |
11: Reversibility |
Reading data. Fitting. Random numbers, seeds, MC integration |
Week 5: |
14: Domain Languages |
Spline interpolation, Model fitting (least squares) |
Week 6: |
18: Power Editing |
Version control (git/mercurial/jujitsu), Sums and Integrals (trapezoid), Changing variables |
Week 7: |
20: Debugging |
Debugging code, ODEs |
Week 8: |
23: Design by Contract |
PDEs |
Week 9: |
26: How to Balance Resources |
Optimization and Root Finding |
Week 10: |
30: Transforming Programming |
Data Types: Sets, Tuples, Maps/Dictionaries, Stacks, Trees (binary), Hashtables |
Week 11: |
34: Shared State is Incorrect State |
Linear algebra, Condition number, LU/Cholesky, QR (Gram Schmidt), Eigenvalues, SVD, \(e^{\mat{M}}\) |
Week 12: |
36: Blackboards |
TBD |
Week 13: |
39: Algorithm Speed |
Algorithms, Complexity, Memory, Testing |
Week 14: |
43: Stay Safe Out There |
Plotting, Log/Log, Axes labels, Units, Legends, Histograms, 3D, Animations |
Week 15: |
51: Pragmatic Starter Kit |
(Thanksgiving - No class) |
Week 16: |
48: The Essence of Agility |
(Dead week) |
Specific Skills#
Oracle Expert Familiar Aware unaware
Programming Constructs
Loops
Conditionals
Classes (Object Oriented)
Coroutines
Printing
Reading input/files
Installing stuff
Windows Subsystem for Linux
Understand floating point numbers:
[E, A] Model for estimating round-off error.
[E, F] Estimate the memory requirements for storing arrays of data.
[E, E] Know that single precision exists, and might be of use.
Know how to use pseudo-random numbers:
[F, F] To perform statistical tests of models.
[F, F] Be able to generate arbitrary distributions given uniform deviates. (MCMC)
[F, u] MC integration.
[A, A] Metropolis
[E, E] Know how and why to use a seed.
[F, F] Be aware that not all generators are good, and know how to find good ones.
Know how to load data for analysis:
[F, F] Download data from the internet (
wget,curl, etc.).[A, A] Convert data to a machine-readable format. (Using
regexfor text processing, knowing aboutSQLfor database access,CSVfiles,JSON,YAML,HDM5,.npyand.npzfiles, memory-mapped files, etc.)[A, A] Be able to work with data that does not fit into memory.
[A, A] Have a toolkit for plotting/displaying large amounts of data.
Interpolation:
[F, F] Splines
[F, E] Spectral Methods / RBF
[u, u] Regression?
Signal Analysis:
[E, E] FFT
[F, F] Windowing/Aliasing
[A, u] Linear Predictive Coding (LPC)
Differentiation:
[E, E] Finite difference: truncation vs. round-off errors.
[F, F] Richardson extrapolation.
[F, E] Spectral methods.
[F, u] Automatic differentiation.
Integration:
[E, E] Trapezoidal and Simpsons
[F, A] Quadrature
[F, F] Adaptive integration
[E, E] Changing variables
[F, u] MC integration for high dimensions
ODEs
[E, E] Euler method and error analysis
[F, u] Backward Euler (stiff ODEs)
[F, F] RK45
[A, u] Bulrich-Stoer (Richardson extrapolation)
[E, E] Changing variables
PDEs
[E, E] Finite Difference: boundary conditions
[F, E] Spectral Methods (Basis expansion)
[F, A] Pseudo Spectral Methods (DVR) (Basis expansion with colocation points)
[A, A] Finite Element Methods
[F, E] [Courant-Freidrichs-Lewy condition][] (CFL)
[A, E] Tensor product (higher dimensions)
Optimization/Root Finding:
[E, F] Gradient Descent
[E, E] Newton’s Method
[F, A] Broyden’s Method (and L-BGFS-B)
Data Types:
[E, E] Sets
[E, E] Tuples
[F, u] Linked Lists
[E, E] Stack
[E, u] Queues (parallel programming)
[F, F] Trees
[F, F] Balanced binary trees.
[F, F] [\(k\)-d trees][]
[A, A] Where \(\log N\) comes into costs.
[F, F] Graphs/Networks
[F, F] Hash-tables
[F, u] Heaps
[F, F] Priority Queues
[E, E] Arrays
[F, F] Sparse arrays
Algorithms:
[E, F] o() O() notation
[E, F] Searching
[E, F] Sorting
[E, A] Quick sort (\(N^2\) worst-case)
[E, A] Merge sort/Heap sort (\(N\log N\) worst case)
[E, A] Radix sort.
[A, F] Primality testing?
[F, A] Convex Hull
[F, A] Tree/graph traversal (BFS, DFS, Dijkstra, Min-cut/Max-flow)
[A, u] Dynamic Programming (What algorithms are best? Is there one that has a good quantum solution? I seem to recall the Knapsack problem having a quantum solution…)
[E, E] FFT
[E, E] Convolution theorem
[A, A] Big Number multiplication
[E, E] SVD/Eigenvalues/Krylov
[A, A] Multigrid (Galerkin)
[A, A] Multipole
Linear Algebra:
[E, u] Condition number.
[E, F] LU/Cholesky
[E, E] QR (Gram Schmidt)
[E, E] Eigenvalues
[E, E] SVD
[E, E] Matrix Exponential
Taylor Expansion
Diagonalization
Troterization
ODE
Plotting:
[E, E] Log-Log etc.
[E, E] Axis labels. Units.
[E, E] Histograms (errors), KDE
[F, F] 3D
[F, F] Animations
Languages:
[F, F] Python
Numpy/Scipy/Pandas/Matplotlib/Uncertainties/Sympy
[F, F] C++/Fortran
[F, F] MATLAB
[A, A] Julia
[A, A] Make
[F, F] Bash (Terminal)
[A, A] Regex
[F, F] Sympy/Maple/Mathematica
[A, A] Spreadsheets
[A, A] Haskell/F#/Verse
[A, A] SQL
[A, A] HTML/CSS
[A, A] Java
[A, A] Javascript/Typescript
[F, F] TeX/LaTeX
Tools
git
hg
jujutsu
jinja
cpp
linters
sed/awk
make/cmake
curl/wget
conda/pip/pdm/npm/apt/macports/homebrew
tar/gzip/zip
imagemagick/ffmpeg
Editors (Emacs/Vi/VS-Code/Spyder/PyCharm)
JupyterLab
Jupyterbook
Sphinx
PyTest
Hardware
CPU/FPU
GPU
[A, u] Cache
Memory
Disk
Bus
Pipelines
Network
Pragmatic Programming
Problem solving with Code (How to tell a computer how to solve your problem. Advantages of different languages.)
Recursion. Tail recursion. Stackless programming
Iterative vs Declarative
Scope
Cache
Parallel Programming
Debugging
Optimization
Algorithms: o() O() notation Searching Sorting Quick sort (\(N^2\) worst-case) Merge sort/Heap sort (\(N\log N\) worst case) Radix sort. Primality testing? Convex Hull Tree/graph traversal (BFS, DFS, Dijkstra, Min-cut/Max-flow) Dynamic Programming FFT Convolution theorem Big Number multiplication SVD/Eigenvalues/Krylov Multigrid (Galerkin) Multipole
Linear Algebra: Condition number LU/Cholesky QR (Gram Schmidt) Eigenvalues SVD Matrix Exponential Taylor Expansion Diagonalization Troterization ODE
Plotting: Log-Log etc Axis labels. Units Histograms (errors), KDE 3D Animations
Languages: Python Numpy/Scipy/Pandas/Matplotlib/Uncertainties/Sympy C++/Fortran MATLAB Julia Make Bash (Terminal) Regex Sympy/Maple/Mathematica Spreadsheets Haskell/F#/Verse SQL HTML/CSS Java Javascript/Typescript TeX/LaTeX
Tools git hg jujutsu jinja cpp linters sed/awk make/cmake curl/wget conda/pip/pdm/npm/apt/macports/homebrew tar/gzip/zip imagemagick/ffmpeg
Editors (Emacs/Vi/VS-Code/Spyder/PyCharm) JupyterLab Jupyterbook Sphinx PyTest
Hardware CPU/FPU GPU Cache Memory Disk Bus Pipelines Network
Pragmatic Programming
Problem solving with Code (How to tell a computer how to solve your problem. Advantages of different languages.)
Recursion. Tail recursion. Stackless programming
Iterative vs Declarative
Scope
Cache
Parallel Programming
Debugging
Optimization
Expectations for Student Effort#
Students are expected to:
Stay up to date with reading assignments.
Participate in online forums, both asking questions and addressing peers questions.
Identify areas of weakness, work with peers to understand difficult concepts, then present remaining areas of difficulty to the instructor for personal attention or for discussion in class.
Complete assignments on time, providing well crafted solutions to the posed problems that demonstrate mastery of the material through the Learning Outcomes 1-7.
Student’s are encouraged to discuss their intended approach with peers and with the instructor, but must ultimately write their own code.
For each hour of lecture equivalent, students should expect to have a minimum of two hours of work outside class.
Assessment and Grading Policy#
Submit and have approved 2 Pull Requests (Merge Requests) resolving issues in open source project hosted on GitHub (or GitLab) or the class project. Be careful to familiarize yourselves with the community guidelines for the projects, and follow their protocol for ensuring that your contribution meets style, testing, and documentation guidelines. Projects outside of the class repository must be approved by your instructor.
Maintain your own repository for the class where you solve the assigned problems, and document your solutions. Template projects will be provided using JupyterBook.
Pose, solve, and document a problem of interest from your domain of study, producing a paper in the format of a journal relevant for your field. The paper need not be submitted or accepted for publication, but this should be your goal. Papers will undergo in-class review.
Grading will be largely automated: you are expected to maintain a project on GitLab where you keep the code in a Git clone of the Official Course Repository. Your projects should contain all of the code you develop for this course, including solutions to the assignments. This code should be well-documented, and well-tested using GitLab’s continuous integration (CI) tools.
Each assignment (see Assignment Instructions for details) will be distributed as a set of
files made available through the main branch of the Official Course Repository: you
will be instructed when to pull and merge these with your project. These assignments
will contain skeleton code and tests. You will be expected to complete the skeleton
code so that the tests pass.
These will include python code with skeleton functions, class, etc. which you are expected to complete, along with automated tests (which you must not modify) for the assignment, and CI instructions such that these tests can be run on GitLab, producing a badge for that assignment.
Your numeric grade for the course will be the percentage of passing assignment test badges for your code. Thus, if there are 10 assignments in the course and you have passing tests for 8 of those, you will have a grade of 80%.
The final grade will be converted to a letter grade using the following scale:
Percentage P |
Grade |
|---|---|
90.0% ≤ P |
A |
85.0% ≤ P < 90.0% |
A- |
80.0% ≤ P < 85.0% |
B+ |
75.0% ≤ P < 80.0% |
B |
70.0% ≤ P < 75.0% |
B- |
65.0% ≤ P < 70.0% |
C+ |
60.0% ≤ P < 65.0% |
C |
55.0% ≤ P < 60.0% |
C- |
50.0% ≤ P < 55.0% |
D+ |
40.0% ≤ P < 50.0% |
D |
P < 40.0% |
F |
As discussed in section Assignment Instructions, there will be two stages of testing for each assignment. Completion of the first stage tests will allow you to get up to a grade of A-. Successful completion of sufficient second stages will be required for an overall A in the course. Currently there is no other mechanism for partial credit, but I will attempt to implement this during the course.
As a fail-safe, you will get a minimum grade of a B+ if you meet the following requirements:
You make a reasonable attempt to solve the assignments by writing functioning code in your project. This code should be well documented, appropriately commented, and should follow best coding practices.
You write comprehensive automated tests for your code which pass when run using the GitLab CI, resulting in at least 85% code coverage.
You participate in at least one formal code review of either code pertaining to a project in your domain of focus, or a randomly selected assignment, where we go over your code as a class, looking for potential bugs, places for optimizing performance, etc.
The main branch of the Official Course Repository will meet these requirements, and
will provide a skeleton of all the code needed to make and run the tests. Thus, you should be
able to easily maintain this standard as you develop code, obtaining a minimum
grade of B+ with modest effort. I expect some of the assignments will be challenging,
so to obtain a grade of A will require some commitment and skill.
There will be no exams in this course.
Attendance and Make-up Policy#
While there is no strict attendance policy, students are expected attend an participate in classroom activities and discussion. Students who miss class are expected to cover the missed material on their own, e.g. by borrowing their classmates notes, reviewing recorded lectures (if available), etc.
Course Timeline#
The following details the content of the course. It essentially follows the main textbook. Content from the supplement will be inserted as appropriate throughout. Details and further resources will be included on the lecture pages on the Canvas server.
Introduction and Basic Principles (~2-3 week)
Basic Techniques (~2-3 weeks)
Differentiation and Integration.
Optimization and Root Finding.
Interpolation: Splines, Polynomials, Radial Basis Functions (RBF), Gaussian Processes.
Loops, Arrays, etc.
Bases.
Curve Fitting/Cycle Finding (~2 week)
Finding cycles in data.
Least squares fitting.
Fourier analysis.
Other techniques.
Bayesian techniques.
Ordinary Differential Equations (ODEs) (~1-2 week)
Orbiting Planets.
Falling Objects.
Agent-Based Modeling.
Partial Differential Equations (PDFs) (~2 weeks)
Schrodinger Equation
Fluid Dynamics
Diffusion
Other Topics/Domain Specific Problems (~4-6 weeks)
Renormalization Group, Effective Theories
Cellular Automata
Domain specific problems designed to address challenging problems in the fields of study represented by participants in the class.
Visualization techniques.
Profiling and Optimization.
Topics#
Exact topics and techniques will be chosen to match the interests and needs of the participants (who are expected to communicate these needs to the instructor in advance of the course), but may include:
Case-studies: Part of the course will explore real-world examples of how physics has inspired solutions to hard problems in other fields of study.
Root-finding and Optimization
Finding ground states and excited states in quantum mechanics.
Density Functional Theory (DFT)
Machine learning (Probably not in the first year…)
Reaction/Diffusion networks:
Heat flow.
Hair follicle morphogenesis (Turing’s problem).
Ordinary Differential equations and Boundary Value Problems:
Classical Mechanics
Classical Chaos
Time-dependent Schrödinger equation.
Partial Differential Equations
Time-dependent Schrödinger equation/Time-dependent DFT (TDDFT)
Fluid dynamics (Continuing from Matt’s course).
Simple parallization: what to do when your data does not fit on a single node. (@m.duez)
Numerical Relativity (Probably not in the first year…)
Finite element techniques + Green’s Functions for wave dynamics (Talk to Phil).
Monte Carlo
Simulation of thermodynamic systems
Numerical experiments with Renormalization Group
Quantum Monte Carlo (QMC) (Probably not in the first year…)
Bayesian Analysis
Linear and Non-linear model fitting which properly characterized errors.
Manifold reduction techniques.
Data Analysis
How to access, store, and analyze data.
Clustering and searching in high dimensions. (@gworthey)
Other Information#
Policy for the Use of Large Language Models (LLMs) or Generative AI in Physics Courses#
The use of LLMs or Generative AI such as Chat-GPT is becoming prevalent, both in education and in industry. As such, we believe that it is important for students to recognize the capabilities and inherent limitations of these tools, and use them appropriately.
To this end, please submit 4 examples of your own devising:
Two of which demonstrate the phenomena of “hallucination” – Attempt to use the tool to learn something you know to be true, and catch it making plausible sounding falsehoods.
Two of which demonstrate something useful (often the end of a process of debugging and correcting the AI).
Note: one can find plenty of examples online of both cases. Use these to better understand the capabilities and limitations of the AIs, but for your submission, please find your own example using things you know to be true. If you are in multiple courses, you may submit the same four examples for each class, but are encouraged to tailor your examples to the course.
Being able to independently establish the veracity of information returned by a search, an AI, or indeed any publication, is a critical skill for a scientist. If you are the type of employee who can use tools like ChatGPT to write prose, code etc., but not accurately validate the results, then you are exactly the type of employee that AI will be able to replace.
Any use of Generative AI or similar tools for submitted work must include:
A complete description of the tool. (E.g. “ChatGPT Version 3.5 via CoCalc’s interface” or Chat-GPT 4 through Bing AI using the Edge browser”, etc.)
A complete record of the queries issued and response provided. (This should be provided as an attachment, appendices, or supplement.)
An attribution statement consistent with the following: “The author generated this <text/code/etc.> in part with <GPT-3, OpenAI’s large-scale language-generation model/etc.> as documented in appendix <1>. Upon generating the draft response, the author reviewed, edited, and revised the response to their own liking and takes ultimate responsibility for the content.”
Academic Integrity#
You are responsible for reading WSU’s Academic Integrity Policy, which is based on Washington State law. If you cheat in your work in this class you will:
Fail the course.
Be reported to the Center for Community Standards.
Have the right to appeal the instructor’s decision.
Not be able to drop the course or withdraw from the course until the appeals process is finished.
If you have any questions about what you can and cannot do in this course, ask your instructor.
If you want to ask for a change in the instructor’s decision about academic integrity, use the form at the Center for Community Standards website. You must submit this request within 21 calendar days of the decision.
University Syllabus#
Students are responsible for reading and understanding all university-wide policies and resources pertaining to all courses (for instance: accommodations, care resources, policies on discrimination or harassment), which can be found in the university syllabus.
Students with Disabilities#
Reasonable accommodations are available for students with a documented disability. If you have a disability and need accommodations to fully participate in this class, please either visit or call the Access Center at (Washington Building 217, Phone: 509-335-3417, E-mail: mailto:Access.Center@wsu.edu, URL: https://accesscenter.wsu.edu) to schedule an appointment with an Access Advisor. All accommodations MUST be approved through the Access Center. For more information contact a Disability Specialist on your home campus.
Campus Safety#
Classroom and campus safety are of paramount importance at Washington State University, and are the shared responsibility of the entire campus population. WSU urges students to follow the “Alert, Assess, Act,” protocol for all types of emergencies and the “Run, Hide, Fight” response for an active shooter incident. Remain ALERT (through direct observation or emergency notification), ASSESS your specific situation, and ACT in the most appropriate way to assure your own safety (and the safety of others if you are able).
Please sign up for emergency alerts on your account at MyWSU. For more information on this subject, campus safety, and related topics, please view the FBI’s Run, Hide, Fight video and visit the WSU safety portal.
Students in Crisis - Pullman Resources#
If you or someone you know is in immediate danger, DIAL 911 FIRST!
Student Care Network: https://studentcare.wsu.edu/
Cougar Transit: 978 267-7233
WSU Counseling and Psychological Services (CAPS): 509 335-2159
Suicide Prevention Hotline: 800 273-8255
Crisis Text Line: Text HOME to 741741
WSU Police: 509 335-8548
Pullman Police (Non-Emergency): 509 332-2521
WSU Office of Civil Rights Compliance & Investigation: 509 335-8288
Alternatives to Violence on the Palouse: 877 334-2887
Pullman 24-Hour Crisis Line: 509 334-1133