DSP-in-Python

This repository contains Python examples that follow the Digital Signal Processing (DSP) course by Professor Rich Radke from Rensselaer Polytechnic Institute. The goal is to convert the MATLAB examples used in the course to free, accessible Python examples using NumPy, SciPy, and Matplotlib.

Course Information

• Course: ECSE-4530 Digital Signal Processing
• Instructor: Professor Rich Radke, Rensselaer Polytechnic Institute
• YouTube Playlist: Digital Signal Processing
• Course Website: DSP Video Lectures
• Textbook: Digital Signal Processing by Proakis and Manolakis (4th Edition)

Course Lessons

The course consists of 28 comprehensive lessons covering fundamental and advanced DSP topics:

Part I: Fundamentals (Lessons 1-10a)

• Lesson 1: Discrete-time Signals - Introduction to signal types and discrete-time signal basics
• Lesson 1a: Python for DSP - Python tools and libraries for DSP (NumPy, SciPy, Matplotlib)
• Lesson 2: Linear, Time-Invariant Systems - Impulse response and system properties
• Lesson 3: Convolution and its Properties - Understanding and implementing convolution
• Lesson 4: The Fourier Series - Periodic signal representation
• Lesson 5: The Fourier Transform - Transition from time to frequency domain
• Lesson 6: Frequency Response - System analysis in the frequency domain
• Lesson 7: The Discrete-Time Fourier Transform - DTFT theory and applications
• Lesson 8: The z-Transform - Transform methods for discrete systems
• Lesson 9: The Inverse z-Transform; Poles and Zeros - System analysis using poles and zeros
• Lesson 10: The Discrete Fourier Transform - DFT and its properties
• Lesson 10a: Exam 1 Review - Midterm preparation and review

Part II: Fast Algorithms and Sampling (Lessons 11-15)

• Lesson 11: Radix-2 Fast Fourier Transforms - Efficient FFT algorithms
• Lesson 12: The Cooley-Tukey and Good-Thomas FFTs - Advanced FFT algorithms
• Lesson 13: The Sampling Theorem - Nyquist sampling and aliasing
• Lesson 14: Continuous-Time Filtering with Digital Systems; Upsampling and Downsampling - Rate conversion
• Lesson 15: Multirate Signal Processing and Polyphase Representations - Efficient multirate systems

Part III: Filter Design (Lessons 16-18)

• Lesson 16: FIR Filter Design (Least-Squares) - FIR filter design using least-squares method
• Lesson 17: FIR Filter Design (Chebyshev) - Chebyshev approximation for FIR filters
• Lesson 18: IIR Filter Design - Infinite impulse response filter design

Part IV: Adaptive Filters (Lessons 19-22a)

• Lesson 19: Introduction to Adaptive Filtering; ARMA Processes - Statistical signal processing and adaptive filtering introduction
• Lesson 20: The Wiener Filter - Optimal filtering for noise reduction
• Lesson 21: Gradient Descent and LMS - Adaptive filter algorithms
• Lesson 22: Least Squares and Recursive Least Squares - RLS algorithms for parameter estimation
• Lesson 22a: Exam 2 Review - Final exam preparation and review

Part V: Quantization and Advanced Topics (Lessons 23-25)

• Lesson 23: Introduction to Quantization - Analog-to-digital conversion
• Lesson 24: Differential Quantization and Vocoding - Advanced quantization methods
• Lesson 25: Perfect Reconstruction Filter Banks; Introduction to Wavelets - Subband coding and wavelet theory

Repository Structure

Each lesson has its own directory containing:

• README.md: Lesson overview, objectives, and references to the video lecture
• examples/: Python scripts demonstrating key concepts
• exercises/: Practice problems (where applicable)
• data/: Sample data files for demonstrations

DSP-in-Python/
├── README.md
├── requirements.txt
├── LICENSE
├── .gitignore
├── lessons/
│   ├── lesson_01/
│   ├── lesson_01a/
│   ├── lesson_02/
│   ├── lesson_03/
│   ├── ...
│   └── lesson_25/
└── utils/
    └── common_functions.py

Getting Started

Prerequisites

• Python 3.8 or higher
• pip package manager

Installation

1. Clone this repository:

   git clone https://github.com/n7jti/DSP-in-Python.git
   cd DSP-in-Python

2. Install required packages:

   pip install -r requirements.txt

Running Examples

Navigate to any lesson directory and run the Python scripts:

cd lessons/lesson_01/examples
python signal_types.py

Python Libraries Used

This repository uses free and open-source Python libraries:

• NumPy: Numerical computing and array operations
• SciPy: Scientific computing, including signal processing functions
• Matplotlib: Plotting and visualization
• IPython/Jupyter: Interactive computing (optional)

Contributing

Contributions are welcome! If you'd like to add examples, fix bugs, or improve documentation:

1. Fork the repository
2. Create a feature branch (git checkout -b feature/new-example)
3. Commit your changes (git commit -m 'Add new example for Lesson X')
4. Push to the branch (git push origin feature/new-example)
5. Open a Pull Request

Please ensure your code follows Python best practices (PEP 8) and includes appropriate comments.

License

This project is licensed under the MIT License - see the LICENSE file for details.

Acknowledgments

• Professor Rich Radke for creating and sharing the excellent DSP course
• Rensselaer Polytechnic Institute for making the course materials publicly available
• The open-source Python community for the amazing scientific computing tools

Additional Resources

• Rich Radke's YouTube Channel
• SciPy Signal Processing Documentation
• NumPy Documentation
• Matplotlib Documentation

Contact

For questions or suggestions, please open an issue on GitHub.