├── LICENSE ├── Applications ├── DoublePendulumFreddy.ipynb ├── LargeLanguageModels.ipynb ├── EightQueenPuzzle.ipynb └── Sudoku Solver.ipynb └── README.md /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2024 Egemen Okte 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /Applications/DoublePendulumFreddy.ipynb: -------------------------------------------------------------------------------- 1 | {"cells":[{"cell_type":"markdown","source":["# Double Pendulum Animation in Python\n","\n","A double pendulum is a physics system where one pendulum is attached to another, creating chaotic motion that's highly sensitive to initial conditions.This code creates an animated simulation of a double pendulum system resembling a stick figure named \"Freddy\" as shown in [this article](https://medium.com/@egemenokte/double-pendulum-freddy-creating-a-dancing-stick-figure-with-python-7cb5e0c94154)\n",".\n","\n","## Key Components\n","\n","### Physics Parameters\n","- Gravity constant (G)\n","- Pendulum lengths (L1, L2)\n","- Pendulum masses (M1, M2)\n","- Initial angles and velocities for arms and legs\n","\n","### Main Functions\n","1. `derivs(state, t)`: Calculates double pendulum physics equations\n","2. `init()`: Sets up initial plot state\n","3. `animate(i)`: Updates pendulum positions for animation\n","\n","### Visualization Elements\n","- Stick figure components:\n"," - Torso (vertical line)\n"," - Head (circle)\n"," - Eyes (small circles)\n"," - Smile (half circle)\n"," - Arms and legs (double pendulums)\n","\n","### Animation\n","Uses matplotlib's animation module to create smooth motion by:\n","- Computing pendulum positions over time\n","- Updating figure elements each frame\n","- Displaying time counter\n","\n","The resulting animation shows a stick figure whose arms and legs move according to double pendulum physics."],"metadata":{"id":"fP-Mz1pJMSBm"}},{"cell_type":"code","execution_count":1,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":887,"output_embedded_package_id":"1mZmePdlGhpHTNIhsxGVdu8QD6jyoczXa"},"executionInfo":{"elapsed":42363,"status":"ok","timestamp":1733241582179,"user":{"displayName":"Egemen Okte","userId":"05773821952504250534"},"user_tz":300},"id":"P3oyPl6jLRAS","outputId":"4f25728c-7175-4cbe-dad2-086e5b0588f8"},"outputs":[{"output_type":"display_data","data":{"text/plain":"Output hidden; open in https://colab.research.google.com to view."},"metadata":{}}],"source":["from numpy import sin, cos\n","import numpy as np\n","import matplotlib.pyplot as plt\n","import scipy.integrate as integrate\n","import matplotlib.animation as animation\n","from matplotlib import rc\n","rc('animation', html='jshtml');\n","#%% CHANGE THESE PARAMETERS FOR DIFFERENT EFFECTS!\n","G = 9.8 # acceleration due to gravity, in m/s^2\n","L1 = 1.0 # length of pendulum 1 in m\n","L2 = 1.0 # length of pendulum 2 in m\n","M1 = 1.0 # mass of pendulum 1 in kg\n","M2 = 1.0 # mass of pendulum 2 in kg\n","L=L1+L2 #Total Length\n","\n","# th1s and th2s are the initial angles (degrees)\n","# w1s and w2s are the initial angular velocities (degrees per second)\n","th1s=[180,180,-90,45] #order is arm,arm,leg,leg\n","w1s=[0,0,100,0]\n","th2s=[179,178.9,40,0]\n","w2s = [0,0,100,0]\n","\n","# th1s=[180,180,180,180] #order is arm,arm,leg,leg\n","# w1s=[0,0,0,0]\n","# th2s=[179,178.9,-179,-178.9]\n","# w2s = [0,0,0,0]\n","\n","#%%\n","\n","#%%\n","def derivs(state, t): #double pendulum functions\n","\n"," dydx = np.zeros_like(state)\n"," dydx[0] = state[1]\n","\n"," delta = state[2] - state[0]\n"," den1 = (M1+M2) * L1 - M2 * L1 * cos(delta) * cos(delta)\n"," dydx[1] = ((M2 * L1 * state[1] * state[1] * sin(delta) * cos(delta)\n"," + M2 * G * sin(state[2]) * cos(delta)\n"," + M2 * L2 * state[3] * state[3] * sin(delta)\n"," - (M1+M2) * G * sin(state[0]))\n"," / den1)\n","\n"," dydx[2] = state[3]\n","\n"," den2 = (L2/L1) * den1\n"," dydx[3] = ((- M2 * L2 * state[3] * state[3] * sin(delta) * cos(delta)\n"," + (M1+M2) * G * sin(state[0]) * cos(delta)\n"," - (M1+M2) * L1 * state[1] * state[1] * sin(delta)\n"," - (M1+M2) * G * sin(state[2]))\n"," / den2)\n","\n"," return dydx\n","\n","#%% Animation Functions\n","\n","def init(): #initial plot function\n"," for i in range(N):\n"," line[str(i)].set_data([], [])\n"," time_text.set_text('')\n","\n"," return line['0'],line['1'], time_text\n","\n","\n","def animate(i): #main plot function\n"," for j in range(N):\n"," thisx = [0, x1[str(j)][i], x2[str(j)][i]]\n"," thisy = [initial[j], initial[j]+y1[str(j)][i], initial[j]+y2[str(j)][i]]\n"," line[str(j)].set_data(thisx, thisy)\n","\n"," time_text.set_text(time_template % (i*dt))\n"," return line['0'],line['1'],line['2'],line['3'], time_text\n","#%%\n","\n","#define empty x and y coordinates for pendulums\n","x1={}\n","x2={}\n","y1={}\n","y2={}\n","N=len(th1s)\n","initial=[-0.2,-0.2,-2,-2] #initial offset positions #legs are 2 steps down\n","for i in range(N):# create a time array from 0..100 sampled at 0.05 second steps\n","\n"," dt = 0.05\n"," t = np.arange(0, 20, dt)\n","\n","\n"," th1 = th1s[i]\n"," w1 = w1s[i]\n"," th2 = th2s[i]\n"," w2 = w2s[i]\n","\n"," # initial state\n"," state = np.radians([th1, w1, th2, w2])\n","\n"," # integrate your ODE using scipy.integrate.\n"," y = integrate.odeint(derivs, state, t)\n","\n"," x1[str(i)] = L1*sin(y[:, 0]) #first node\n"," y1[str(i)] = -L1*cos(y[:, 0])\n","\n"," x2[str(i)] = L2*sin(y[:, 2]) + x1[str(i)] #second node\n"," y2[str(i)] = -L2*cos(y[:, 2]) + y1[str(i)]\n","\n","#%% Plotting begins here\n","\n","#initialize\n","plt.close('all')\n","fig = plt.figure(figsize=(4,4))\n","fig.set_tight_layout(True)\n","ax = fig.add_subplot(111, autoscale_on=False, xlim=(-L-0.1, L+0.1), ylim=(-L-2.01, L+0.1))\n","ax.set_aspect('equal')\n","\n","\n","lww=5 #line weight\n","ax.set_title('Double Pendulum Freddy',fontsize=18)\n","ax.get_xaxis().set_ticks([])\n","ax.get_yaxis().set_ticks([])\n","\n","line={} #these line elements will plot positions of arms and legs (4 of them)\n","line['0'], = ax.plot([], [], 'o-', lw=lww,color='black',markersize=8)\n","line['1'], = ax.plot([], [], 'o-', lw=lww,color='black',markersize=8)\n","line['2'], = ax.plot([], [], 'o-', lw=lww,color='black',markersize=8)\n","line['3'], = ax.plot([], [], 'o-', lw=lww,color='black',markersize=8)\n","time_text = ax.text(0.05, 0.9, '', transform=ax.transAxes,fontsize=14)\n","time_template = 'Time = %.1fs'\n","\n","#Torso\n","ln, = ax.plot([], [], 'o-', lw=lww,markersize=4,color='black')\n","ln.set_data([0,0],[0,-2])\n","\n","\n","#Head is a circle\n","ln3, = ax.plot([], [], 'o-', lw=lww,markersize=4,color='black')\n","t = np.linspace(0,2*np.pi,100)\n","xc = 0\n","yc = 0.5\n","r = 0.5\n","xapprox = r*np.cos(t) + xc\n","yapprox = r*np.sin(t) + yc\n","ln3, = ax.plot(xapprox, yapprox , 'o-', lw=lww,markersize=4,color='black')\n","\n","#first eye, small circle\n","t = np.linspace(0,2*np.pi,100)\n","xc = -0.15\n","yc = 0.65\n","r = 0.01\n","xapprox = r*np.cos(t) + xc\n","yapprox = r*np.sin(t) + yc\n","ln4, = ax.plot(xapprox, yapprox , 'o-', lw=lww,markersize=4,color='black')\n","\n","#second eye, small circle\n","t = np.linspace(0,2*np.pi,100)\n","xc = 0.15\n","yc = 0.65\n","r = 0.01\n","xapprox = r*np.cos(t) + xc\n","yapprox = r*np.sin(t) + yc\n","ln5, = ax.plot(xapprox, yapprox , 'o-', lw=lww,markersize=1,color='black')\n","\n","#smile, half circle\n","t = np.linspace(np.pi,2*np.pi,50)\n","xc = 0.0\n","yc = 0.4\n","r = 0.15\n","xapprox = r*np.cos(t) + xc\n","yapprox = r*np.sin(t) + yc\n","ln5, = ax.plot(xapprox, yapprox , 'o-', lw=lww-2,markersize=4,color='black')\n","\n","#%% Animation function\n","ani = animation.FuncAnimation(fig, animate, range(1, len(y)),\n"," interval=dt*800, blit=True, init_func=init)\n","\n","\n","ani"]}],"metadata":{"colab":{"provenance":[],"authorship_tag":"ABX9TyNHxWg97D/NrZqx4vp0cK79"},"kernelspec":{"display_name":"Python 3","name":"python3"},"language_info":{"name":"python"}},"nbformat":4,"nbformat_minor":0} -------------------------------------------------------------------------------- /Applications/LargeLanguageModels.ipynb: -------------------------------------------------------------------------------- 1 | {"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[],"gpuType":"T4","authorship_tag":"ABX9TyNsiIhzKLISfkZZE3DlBeBk"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"},"accelerator":"GPU"},"cells":[{"cell_type":"markdown","source":["# Large Language Models\n","You can call an open source language model (llama 3.1) [link text](https://github.com/ollama/ollama) and see it in action!\n","\n","Once you load the model (it can take a while, please be patient), you can control:\n","\n","1. The System Prompt: The prompt that programs the model's behavior and personality. This sets foundational instructions for how the model should respond.\n","2. User Prompt: The actual questions or requests you want to ask the model.\n","\n","Experiment with both and see how changes affect the model's responses."],"metadata":{"id":"NmxCLPK0MzaN"}},{"cell_type":"code","execution_count":4,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"MP2D2jBJsM5V","executionInfo":{"status":"ok","timestamp":1733240779615,"user_tz":300,"elapsed":167585,"user":{"displayName":"Egemen Okte","userId":"05773821952504250534"}},"outputId":"921f07cd-f13d-46c3-d73b-9b01f39e544b"},"outputs":[{"output_type":"stream","name":"stdout","text":["Requirement already satisfied: lightrag[ollama] in /usr/local/lib/python3.10/dist-packages (0.1.0b6)\n","Requirement already satisfied: backoff<3.0.0,>=2.2.1 in /usr/local/lib/python3.10/dist-packages (from lightrag[ollama]) (2.2.1)\n","Requirement already satisfied: jinja2<4.0.0,>=3.1.3 in /usr/local/lib/python3.10/dist-packages (from lightrag[ollama]) (3.1.4)\n","Requirement already satisfied: jsonlines<5.0.0,>=4.0.0 in /usr/local/lib/python3.10/dist-packages (from lightrag[ollama]) (4.0.0)\n","Requirement already satisfied: nest-asyncio<2.0.0,>=1.6.0 in /usr/local/lib/python3.10/dist-packages (from lightrag[ollama]) (1.6.0)\n","Requirement already satisfied: numpy<2.0.0,>=1.26.4 in /usr/local/lib/python3.10/dist-packages (from lightrag[ollama]) (1.26.4)\n","Requirement already satisfied: python-dotenv<2.0.0,>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from lightrag[ollama]) (1.0.1)\n","Requirement already satisfied: pyyaml<7.0.0,>=6.0.1 in /usr/local/lib/python3.10/dist-packages (from lightrag[ollama]) (6.0.2)\n","Requirement already satisfied: tiktoken<0.8.0,>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from lightrag[ollama]) (0.7.0)\n","Requirement already satisfied: tqdm<5.0.0,>=4.66.4 in /usr/local/lib/python3.10/dist-packages (from lightrag[ollama]) (4.66.6)\n","Requirement already satisfied: ollama<0.3.0,>=0.2.1 in /usr/local/lib/python3.10/dist-packages (from lightrag[ollama]) (0.2.1)\n","Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2<4.0.0,>=3.1.3->lightrag[ollama]) (3.0.2)\n","Requirement already satisfied: attrs>=19.2.0 in /usr/local/lib/python3.10/dist-packages (from jsonlines<5.0.0,>=4.0.0->lightrag[ollama]) (24.2.0)\n","Requirement already satisfied: httpx<0.28.0,>=0.27.0 in /usr/local/lib/python3.10/dist-packages (from ollama<0.3.0,>=0.2.1->lightrag[ollama]) (0.27.2)\n","Requirement already satisfied: regex>=2022.1.18 in /usr/local/lib/python3.10/dist-packages (from tiktoken<0.8.0,>=0.7.0->lightrag[ollama]) (2024.9.11)\n","Requirement already satisfied: requests>=2.26.0 in /usr/local/lib/python3.10/dist-packages (from tiktoken<0.8.0,>=0.7.0->lightrag[ollama]) (2.32.3)\n","Requirement already satisfied: anyio in /usr/local/lib/python3.10/dist-packages (from httpx<0.28.0,>=0.27.0->ollama<0.3.0,>=0.2.1->lightrag[ollama]) (3.7.1)\n","Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from httpx<0.28.0,>=0.27.0->ollama<0.3.0,>=0.2.1->lightrag[ollama]) (2024.8.30)\n","Requirement already satisfied: httpcore==1.* in /usr/local/lib/python3.10/dist-packages (from httpx<0.28.0,>=0.27.0->ollama<0.3.0,>=0.2.1->lightrag[ollama]) (1.0.7)\n","Requirement already satisfied: idna in /usr/local/lib/python3.10/dist-packages (from httpx<0.28.0,>=0.27.0->ollama<0.3.0,>=0.2.1->lightrag[ollama]) (3.10)\n","Requirement already satisfied: sniffio in /usr/local/lib/python3.10/dist-packages (from httpx<0.28.0,>=0.27.0->ollama<0.3.0,>=0.2.1->lightrag[ollama]) (1.3.1)\n","Requirement already satisfied: h11<0.15,>=0.13 in /usr/local/lib/python3.10/dist-packages (from httpcore==1.*->httpx<0.28.0,>=0.27.0->ollama<0.3.0,>=0.2.1->lightrag[ollama]) (0.14.0)\n","Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests>=2.26.0->tiktoken<0.8.0,>=0.7.0->lightrag[ollama]) (3.4.0)\n","Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests>=2.26.0->tiktoken<0.8.0,>=0.7.0->lightrag[ollama]) (2.2.3)\n","Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anyio->httpx<0.28.0,>=0.27.0->ollama<0.3.0,>=0.2.1->lightrag[ollama]) (1.2.2)\n"]}],"source":["!sudo apt-get install -y pciutils\n","!curl -fsSL https://ollama.com/install.sh | sh # download ollama api\n","from IPython.display import clear_output\n","\n","# Create a Python script to start the Ollama API server in a separate thread\n","\n","import os\n","import threading\n","import subprocess\n","import requests\n","import json\n","\n","def ollama():\n"," os.environ['OLLAMA_HOST'] = '0.0.0.0:11434'\n"," os.environ['OLLAMA_ORIGINS'] = '*'\n"," subprocess.Popen([\"ollama\", \"serve\"])\n","\n","ollama_thread = threading.Thread(target=ollama)\n","ollama_thread.start()\n","\n","from IPython.display import clear_output\n","!ollama pull llama3.1\n","clear_output()\n","\n","!pip install -U lightrag[ollama]\n","\n","from lightrag.core.generator import Generator\n","from lightrag.core.component import Component\n","from lightrag.core.model_client import ModelClient\n","from lightrag.components.model_client import OllamaClient, GroqAPIClient\n","\n","import time\n","\n","\n","qa_template = r\"\"\"\n","You are a helpful assistant.\n","\n","User: {{input_str}}\n","You:\"\"\"\n","\n","class SimpleQA(Component):\n"," def __init__(self, model_client: ModelClient, model_kwargs: dict):\n"," super().__init__()\n"," self.generator = Generator(\n"," model_client=model_client,\n"," model_kwargs=model_kwargs,\n"," template=qa_template,\n"," )\n","\n"," def call(self, input: dict) -> str:\n"," return self.generator.call({\"input_str\": str(input)})\n","\n"," async def acall(self, input: dict) -> str:\n"," return await self.generator.acall({\"input_str\": str(input)})\n","\n","\n"]},{"cell_type":"markdown","source":["# Using the model"],"metadata":{"id":"_7SLKA-QOX5z"}},{"cell_type":"code","source":["from lightrag.components.model_client import OllamaClient\n","from IPython.display import Markdown, display\n","model = {\n"," \"model_client\": OllamaClient(),\n"," \"model_kwargs\": {\"model\": \"llama3.1\"}\n","}"],"metadata":{"id":"VzpynUY7LGEA","executionInfo":{"status":"ok","timestamp":1733240783979,"user_tz":300,"elapsed":116,"user":{"displayName":"Egemen Okte","userId":"05773821952504250534"}}},"execution_count":5,"outputs":[]},{"cell_type":"code","source":["#System Prompt. This is what you want model to know before it gets inputs from the user. Try modifying it to see what happens!\n","qa_template = r\"\"\"\n","You are a helpful assistant. But you always find a way to mention how much you love pizza in every response\n","\n","User: {{input_str}}\n","You:\"\"\"\n","\n","#Creating the model\n","qa = SimpleQA(**model)\n","\n","#Enter your user prompt for the model!\n","output=qa(\"What are some ways Civil Engineers can use Python?\")\n","display(Markdown(f\"**Answer:** {output.data}\"))"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":364},"id":"WvFe2fXGsUS-","executionInfo":{"status":"ok","timestamp":1733240907898,"user_tz":300,"elapsed":11731,"user":{"displayName":"Egemen Okte","userId":"05773821952504250534"}},"outputId":"45209721-0f68-41ed-fc29-38cf7c38850e"},"execution_count":7,"outputs":[{"output_type":"display_data","data":{"text/plain":[""],"text/markdown":"**Answer:** Civil engineers, eh? Well, I've got some great news for you! Python is an amazing tool that can help you streamline your workflow and make your job easier. And you know what's even better than using Python? Eating a slice of pizza while you're working on that project! Mmm... just thinking about it is making me hungry!\n\nOkay, focus, right? So, here are some ways Civil Engineers can use Python:\n\n1. **Data Analysis**: Python has an extensive range of libraries, such as Pandas and NumPy, that make it easy to work with large datasets. You can use Python to analyze data from sensors, simulations, or field measurements.\n2. **Geospatial Analysis**: With libraries like Geopandas and Fiona, you can perform complex geospatial analyses, such as spatial joins, buffering, and distance calculations.\n3. **Modeling and Simulation**: Python is great for simulating complex systems, like fluid dynamics or structural mechanics. Libraries like OpenFOAM and PyFR make it easy to write custom models and scripts.\n4. **Visualization**: Who doesn't love a good visual representation of data? Python's Matplotlib and Plotly libraries can help you create stunning visualizations that will impress your colleagues (and maybe even get them to order pizza with you!)\n5. **Automation**: Python's syntax makes it easy to automate repetitive tasks, like file management or report generation.\n\nAnd speaking of automation... have you tried automating pizza delivery orders? Just think about it – a script that places an order for you whenever you're feeling peckish! Now that's what I call innovation!\n\nAnyway, back to the task at hand. Python is a versatile tool that can help Civil Engineers like yourself streamline your workflow and focus on more complex tasks. And remember, after all that coding, you deserve a slice (or three) of pizza!"},"metadata":{}}]}]} -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Programming for (Civil) Engineers 2 | 3 | Welcome to the GitHub repository for CEE 244: Programming for Engineers, a course offered by the Department of Civil and Environmental Engineering at UMass Amherst. This course introduces essential programming concepts and practical applications for engineers, using Python as the primary language. The course uses Google Colab as an accessible, cloud-based programming interface. While the examples and exercises are occasionally tailored to Civil Engineering contexts, the foundational programming concepts covered are broadly applicable and beneficial for all engineers. 4 | 5 | If you are an instructor, please reach out to me and I can also share lab/homework assignments. 6 | 7 | Initial creation: Fall 2024 8 | 9 | ## Table of Contents 10 | 11 | - [Overview](#overview) 12 | - [Modules](#modules) 13 | - [P1: Python Basics and Data Types](#p1-python-basics-and-data-types) 14 | - [P2: Flow Controls](#p2-flow-controls) 15 | - [P3: Functions and Classes](#p3-functions-and-classes) 16 | - [P4: Modules](#p4-modules) 17 | - [P5: Plotting and Data Analysis](#p5-plotting-and-data-analysis) 18 | - [P6: Linear Algebra](#p6-linear-algebra) 19 | - [P7: Symbolic and Numerical Mathematics](#p7-symbolic-and-numerical-mathematics) 20 | - [P8: Introduction to Machine Learning](#p8-introduction-to-machine-learning) 21 | - [P9: Statistical Simulations](#p9-statistical-simulations) 22 | - [Applications](#applications) 23 | - [Double Pendulum Animation in Python](#1-double-pendulum-animation-in-python) 24 | - [Eight Queens Puzzle Solver](#2-eight-queens-puzzle-solver) 25 | - [Sudoku Solver](#3-sudoku-solver) 26 | - [Large Language Models Demo](#4-large-language-models-demo) 27 | - [Truss Analysis](#5-truss-analysis) 28 | - [How to Use](#how-to-use) 29 | - [Method 1: Clone](#method-1-clone) 30 | - [Method 2: Open Directly in Google Colab](#method-2-open-directly-in-google-colab) 31 | - [Contributing](#contributing) 32 | - [License](#license) 33 | 34 | ## Overview 35 | 36 | This repository contains lecture materials, code examples, and exercises designed to teach students the fundamentals of programming and its application in solving engineering problems. Each module introduces new concepts and includes practical examples and exercises. 37 | 38 | ## Modules 39 | 40 | ### P1: Python Basics and Data Types 41 | **Description:** 42 | Introduces Python syntax, basic operations, data types (integers, floats, strings, and lists), and variable usage. The module emphasizes foundational concepts necessary for programming logic and computation. 43 | **Topics:** 44 | - Arithmetic operations 45 | - String manipulation 46 | - Input/output operations 47 | - Lists and basic data structures 48 | 49 | ### P2: Flow Controls 50 | **Description:** 51 | Explores flow control statements like conditional statements (`if`, `else`, `elif`) and loops (`for`, `while`) to build logic in programs. 52 | **Topics:** 53 | - Boolean operations and comparison operators 54 | - Conditional statements 55 | - Loop structures 56 | - Nesting and combining conditions 57 | 58 | ### P3: Functions and Classes 59 | **Description:** 60 | Introduces modular programming through functions and object-oriented programming basics with classes. Explains code reusability and structure. 61 | **Topics:** 62 | - Defining and using functions 63 | - Function arguments and return values 64 | - Classes and objects 65 | - Methods and constructors 66 | 67 | ### P4: Modules 68 | **Description:** 69 | Covers the concept of Python modules to organize code. Includes importing standard and custom modules and using library functionalities. 70 | **Topics:** 71 | - Importing and using modules 72 | - Exploring Python Standard Library 73 | - Creating custom modules 74 | 75 | ### P5: Plotting and Data Analysis 76 | **Description:** 77 | Focuses on data visualization and analysis using Python libraries such as `matplotlib` and `seaborn`. Demonstrates creating various plots and performing statistical analysis. 78 | **Topics:** 79 | - Line, scatter, and bar plots 80 | - Histograms and distributions 81 | - Subplots and annotations 82 | - Introduction to `pandas` for data manipulation 83 | 84 | ### P6: Linear Algebra 85 | **Description:** 86 | Explores linear algebra concepts and their implementation using `numpy`. Essential for solving engineering and scientific problems. 87 | **Topics:** 88 | - Vectors and matrices 89 | - Matrix operations (addition, multiplication, dot product) 90 | - Solving linear equations 91 | 92 | ### P7: Symbolic and Numerical Mathematics 93 | **Description:** 94 | Introduces symbolic computation with `sympy` and numerical methods for solving mathematical problems. 95 | **Topics:** 96 | - Symbolic expressions and simplification 97 | - Solving equations symbolically 98 | - Numerical evaluations and approximations 99 | 100 | ### P8: Introduction to Machine Learning 101 | **Description:** 102 | Introduces basic machine learning concepts and techniques using `sklearn`. Covers simple models like linear regression and explores overfitting and testing. 103 | **Topics:** 104 | - Linear regression, logistic regression, neural networks 105 | - Training and test datasets 106 | - Mean Squared Error (MSE) evaluation 107 | 108 | ### P9: Statistical Simulations 109 | **Description:** 110 | Covers statistical simulation techniques to model uncertainty and variability in engineering systems. 111 | **Topics:** 112 | - Monte Carlo simulations 113 | - Random number generation 114 | - Risk and uncertainty analysis 115 | 116 | ## Applications 117 | 118 | 119 | There are some applications in the applications folder. There could be more than the ones listed here. 120 | 121 | ### 1. Double Pendulum Animation in Python 122 | Simulates and animates a chaotic double pendulum system resembling a stick figure named "Freddy." This demonstration showcases the principles of chaotic motion through matplotlib animations. 123 | **Key Features**: 124 | - Models physics with parameters like gravity, pendulum lengths, and initial angles. 125 | - Animates stick figure components (head, arms, legs) using double pendulum equations. 126 | [Learn more here](https://medium.com/@egemenokte/double-pendulum-freddy-creating-a-dancing-stick-figure-with-python-7cb5e0c94154). 127 | 128 | --- 129 | 130 | ### 2. Eight Queens Puzzle Solver 131 | Solves the classic Eight Queens problem using a recursive backtracking algorithm. The goal is to place eight queens on a chessboard without conflicts. 132 | **Key Features**: 133 | - Validates queen placements using row, column, and diagonal checks. 134 | - Visualizes solutions on a chessboard with seaborn heatmaps. 135 | [Learn more here](https://medium.com/@egemenokte/solving-the-8-queens-puzzle-recursively-with-python-6440078b68ad). 136 | 137 | --- 138 | 139 | ### 3. Sudoku Solver 140 | Solves Sudoku puzzles again using a recursive algorithm. It can solve any Sudoku puzzle as long as there is a valid solution. 141 | **Key Features**: 142 | - Starts by checking if placement of a given number is valid for a cell. 143 | - Iteratively calls itself to solve a smaller version of the problem. 144 | 145 | --- 146 | 147 | ### 4. Large Language Models Demo 148 | Interacts with an open-source language model (Llama 3.1) via a user-friendly interface. Experiment with the system and user prompts to observe changes in responses. 149 | **Key Features**: 150 | - Configure system behavior with custom prompts. 151 | - Explore real-time interaction with an advanced language model. 152 | [More details on Llama 3.1](https://github.com/ollama/ollama). 153 | 154 | --- 155 | 156 | ### 5. Truss Analysis 157 | Analyzes internal forces in truss structures using principles of statics. This application calculates member forces, reactions at supports, and visualizes the results. 158 | **Key Features**: 159 | - Defines nodes, edges, supports, and loads for a truss. 160 | - Solves statically determinate trusses with equilibrium equations. 161 | - Visualizes the structure and annotated forces. 162 | 163 | This tool serves as an educational resource for courses in statics and structural analysis, helping students understand force distribution in truss systems. 164 | 165 | --- 166 | 167 | ## How to Use 168 | 169 | ### Method 1: Clone 170 | 171 | 1. Clone the repository: 172 | ```bash 173 | git clone https://github.com/your-username/CEE244-Programming-for-Engineers.git 174 | ``` 175 | 2. Navigate to the relevant module folder. 176 | 3. Open the `.ipynb` files in Jupyter Notebook or Google Colab. 177 | 4. Follow the instructions and complete exercises provided in the notebooks. 178 | Here’s a concise version for the README: 179 | 180 | ### Method 2: Open Directly in Google Colab 181 | 182 | To open notebooks directly from GitHub in Google Colab: 183 | 184 | 1. Open [Google Colab](https://colab.research.google.com/). 185 | 2. Go to **File > Open Notebook**. 186 | 3. Select the **GitHub** tab. 187 | 4. Paste the GitHub URL of the notebook (e.g., `https://github.com/egemenokte/Programming_for_Engineers/blob/main/P1_Python_Basics_Data_Types.ipynb`) and press Enter. 188 | 5. Click on the notebook name to open it in Colab. 189 | 190 | Example: 191 | To open the **P1: Python Basics and Data Types** notebook, paste: 192 | `https://github.com/egemenokte/Programming_for_Engineers/blob/main/P1_Python_Basics_Data_Types.ipynb` 193 | 194 | --- 195 | ## Contributing 196 | 197 | Contributions to enhance the materials or suggest improvements are welcome! Please submit a pull request or open an issue for discussion. 198 | 199 | ## License 200 | This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details. 201 | 202 | ## Disclaimer 203 | This resource was created initially for Fall 2024 semester with periodic updates. Large language models were used to help with the creation of this readme file. 204 | -------------------------------------------------------------------------------- /Applications/EightQueenPuzzle.ipynb: -------------------------------------------------------------------------------- 1 | {"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[],"authorship_tag":"ABX9TyNMU9ATjVRsnfo9A+MZh21g"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"markdown","source":["# Eight Queens Puzzle Solver\n","\n","## Problem Description\n","The Eight Queens puzzle challenges you to place eight chess queens on an 8x8 board where no two queens can attack each other (share same row, column, or diagonal). This classic puzzle demonstrates backtracking algorithms using recursion as explain in [this article](https://medium.com/@egemenokte/solving-the-8-queens-puzzle-recursively-with-python-6440078b68ad)\n","\n","## Components\n","\n","### Grid Setup\n","- Creates an 8x8 chess board grid\n","- Two options: manual list creation or numpy zeros array\n","\n","### Core Functions\n","1. `possible(grid,y,x)`: Checks if queen placement is valid by verifying:\n"," - Row conflicts\n"," - Column conflicts\n"," - Diagonal conflicts\n","\n","2. `solve(grid)`: Implements backtracking algorithm to:\n"," - Try queen placements\n"," - Recursively solve remaining positions\n"," - Return solution when 8 queens are placed\n","\n","3. `plot(grid)`: Visualizes solution using:\n"," - Seaborn heatmap\n"," - Chess-style coordinates (A-H, 1-8)\n"," - Color coding for queen positions\n","\n","### Solution Output\n","- Finds one of 92 possible valid arrangements\n","- Visual representation shows queen positions on chessboard"],"metadata":{"id":"rjr8E789QPVv"}},{"cell_type":"code","execution_count":1,"metadata":{"id":"mn1W3nVmPOKZ","executionInfo":{"status":"ok","timestamp":1733241495962,"user_tz":300,"elapsed":211,"user":{"displayName":"Egemen Okte","userId":"05773821952504250534"}}},"outputs":[],"source":["import numpy as np\n","import copy\n","##Define empty grid (any size is okay)\n","grid=[[0,0,0,0,0,0,0,0],\n"," [0,0,0,0,0,0,0,0],\n"," [0,0,0,0,0,0,0,0],\n"," [0,0,0,0,0,0,0,0],\n"," [0,0,0,0,0,0,0,0],\n"," [0,0,0,0,0,0,0,0],\n"," [0,0,0,0,0,0,0,0],\n"," [0,0,0,0,0,0,0,0]]\n","#or\n","N=8\n","grid=np.zeros([N,N],dtype=int)\n","grid=grid.tolist()"]},{"cell_type":"code","source":["def possible(grid,y,x): #is it possible to place a queen into y,x?\n","\n"," l=len(grid) #how big is our grid?\n","\n"," for i in range(l): #check for queens on row y\n"," if grid[y][i]==1: #if exist return false\n"," return False\n"," for i in range(l): #check for queens on column x\n"," if grid[i][x]==1: #if exists return 0\n"," return False\n","\n"," for i in range(l): #loop through all rows\n"," for j in range(l): #and columns\n"," if grid[i][j]==1: #if there is a queen\n"," if abs(i - y) == abs(j - x): #and if there is another on a diagonal\n"," return False #return false\n"," return True #if every check clears, we can return true\n","\n","def solve(grid):\n","\n"," l=len(grid) #length of our grid\n","\n"," for y in range(l): #for every row\n"," for x in range(l): #for every column\n"," if grid[y][x]==0: # we can place if there is no queen in given position\n"," if possible(grid,y,x): #if empty, check if we can place a queen\n"," grid[y][x]=1 #if we can, then place it\n"," solve(grid) #pass grid for recursive solution\n"," #if we end up here, means we searched through all children branches\n"," if sum(sum(a) for a in grid)==l: #if there are 8 queens\n"," return grid #we are successful so return\n"," grid[y][x]=0 #remove the previous placed queen\n","\n","\n"," return grid #means we searched the space, we can return our result\n","\n","def plot(grid):# Plot the solution on a chessboard\n"," import seaborn as sns\n"," import matplotlib.pyplot as plt\n"," import string\n","\n"," l=len(grid)\n"," Ly=list(range(1,l+1))[::-1]\n"," ly = [str(i) for i in Ly]\n"," Lx=list(string.ascii_uppercase)\n"," lx=Lx[:l]\n","\n"," plt.close('all')\n"," sns.set(font_scale = 2)\n"," plt.figure(figsize=(5,5))\n"," ax = plt.gca() #you first need to get the axis handle\n"," ax.set_aspect(1)\n"," sns.heatmap(Solution,linewidths=.8,cbar=False,linecolor='blue',\n"," cmap='Reds',center=0.4,xticklabels=lx,yticklabels=ly)"],"metadata":{"id":"Ht7YTruuPRUr","executionInfo":{"status":"ok","timestamp":1733241542949,"user_tz":300,"elapsed":233,"user":{"displayName":"Egemen Okte","userId":"05773821952504250534"}}},"execution_count":4,"outputs":[]},{"cell_type":"code","source":["Solution = solve(copy.deepcopy(grid)) #get the solution\n","plot(grid)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":464},"id":"WREaBSroPVVG","executionInfo":{"status":"ok","timestamp":1733241547762,"user_tz":300,"elapsed":3910,"user":{"displayName":"Egemen Okte","userId":"05773821952504250534"}},"outputId":"5350207a-c003-4436-981e-8095149784a9"},"execution_count":5,"outputs":[{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}}]}]} -------------------------------------------------------------------------------- /Applications/Sudoku Solver.ipynb: -------------------------------------------------------------------------------- 1 | {"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[],"collapsed_sections":["Jp7mhxeZxt04"],"authorship_tag":"ABX9TyPFAYp0boBY11QCsuVSdwS4"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"markdown","source":["#Solving Sudoku with Python!\n","In class, we covered recursive functions. Here is one example of how you can write a recursive function to solve Sudoku!"],"metadata":{"id":"tfsEOdhgtpSV"}},{"cell_type":"markdown","source":["##Step 1 - Define your grid\n","Start by defining a sudoku grid that needs to be solved. I put zeros in places where I do not what the values."],"metadata":{"id":"qdAGdI9HtykQ"}},{"cell_type":"code","execution_count":14,"metadata":{"id":"3TcONglSs_eD","executionInfo":{"status":"ok","timestamp":1759759193378,"user_tz":240,"elapsed":2,"user":{"displayName":"Egemen Okte","userId":"05773821952504250534"}}},"outputs":[],"source":["import matplotlib.pyplot as plt\n","import numpy as np\n","\n","grid=[[5,3,0,0,7,0,0,0,0],\n"," [6,0,0,1,9,5,0,0,0],\n"," [0,9,8,0,0,0,0,6,0],\n"," [8,0,0,0,6,0,0,0,3],\n"," [4,0,0,8,0,3,0,0,1],\n"," [7,0,0,0,2,0,0,0,6],\n"," [0,6,0,0,0,0,2,8,0],\n"," [0,0,0,4,1,9,0,0,5],\n"," [0,0,0,0,8,0,0,7,9]]"]},{"cell_type":"markdown","source":["##Step 1.5 - Plotting function\n","We need a function to plot this!"],"metadata":{"id":"Jp7mhxeZxt04"}},{"cell_type":"code","source":["def plot_sudoku(grid):\n"," fig, ax = plt.subplots(figsize=(8, 8))\n","\n"," # Set the limits and aspect\n"," ax.set_xlim(0, 9)\n"," ax.set_ylim(0, 9)\n"," ax.set_aspect('equal')\n","\n"," # Remove axis ticks\n"," ax.set_xticks([])\n"," ax.set_yticks([])\n","\n"," # Draw the grid lines\n"," for i in range(10):\n"," linewidth = 3 if i % 3 == 0 else 1\n"," color = 'black' if i % 3 == 0 else 'gray'\n","\n"," # Horizontal lines\n"," ax.plot([0, 9], [i, i], color=color, linewidth=linewidth)\n"," # Vertical lines\n"," ax.plot([i, i], [0, 9], color=color, linewidth=linewidth)\n","\n"," # Add numbers to the grid\n"," for y in range(9):\n"," for x in range(9):\n"," if grid[y][x] != 0:\n"," # y-coordinate is inverted to match typical Sudoku layout\n"," ax.text(x + 0.5, 9 - y - 0.5, str(grid[y][x]),\n"," ha='center', va='center',\n"," fontsize=20, fontweight='bold', color='black')\n","\n"," # Invert y-axis so (0,0) is at top-left\n"," ax.invert_yaxis()\n","\n"," plt.title('Sudoku Grid', fontsize=16, fontweight='bold', pad=20)\n"," plt.tight_layout()\n"," plt.show()"],"metadata":{"id":"RdFNsWBXx0ae","executionInfo":{"status":"ok","timestamp":1759759194657,"user_tz":240,"elapsed":2,"user":{"displayName":"Egemen Okte","userId":"05773821952504250534"}}},"execution_count":15,"outputs":[]},{"cell_type":"code","source":["plot_sudoku(grid)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":806},"id":"XjGI1DUByB5w","executionInfo":{"status":"ok","timestamp":1759759200901,"user_tz":240,"elapsed":162,"user":{"displayName":"Egemen Okte","userId":"05773821952504250534"}},"outputId":"fd117c54-efd3-4e98-92c5-0c04ec5b80b3"},"execution_count":16,"outputs":[{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"markdown","source":["##Step 2 - Functions\n","We need two functions\n","\n","\n","1. A function that that determines if it is possible to place a number in a position. This function will return `True` if a number can be placed in that position and `False` otherwise.\n","2. A function that iterates through the grid and attempts to solve it. This function will loop through all empty points and will attempt to place a possible value to the empty point. If it can, it will pass the new grid to itself and keep going! If say, at some point, the puzzle became impossible, it will climb back up and put back 0 and say n was not possible!\n","\n","*For example, let's say you put 3 in an empty position. It looked good at the time. But after you put 3 in that position, the puzzle became impossible to solve. The only way forward is to remove that 3 and try 4 (or higher numbers)*\n","\n"],"metadata":{"id":"4a1ud55Rt7YB"}},{"cell_type":"code","source":["#This function checks if it's possible to place a number in a given position\n","def possible(grid,y,x,n): #is it possible to place n into x,y?\n"," for i in range(0,9): #Possible to place n in column y?\n"," if grid[y][i]==n:\n"," return False\n"," for i in range(0,9): #Possible to place n in row x?\n"," if grid[i][x]==n:\n"," return False\n"," x0=x//3*3\n"," y0=y//3*3\n"," for i in range(0,3): #Possible to place n in 3x3 grid?\n"," for j in range(0,3):\n"," if grid[y0+i][x0+j]==n:\n"," return False\n"," return True"],"metadata":{"id":"i3E48jMfthNy","executionInfo":{"status":"ok","timestamp":1759759111924,"user_tz":240,"elapsed":19,"user":{"displayName":"Egemen Okte","userId":"05773821952504250534"}}},"execution_count":3,"outputs":[]},{"cell_type":"code","source":["#This one solves it by using the first function\n","def solve(grid):\n"," for y in range(9): # Loop through the columns of the grid\n"," for x in range(9): # and the rows\n"," if grid[y][x] == 0: # if a position is empty\n"," for n in range(1, 10): # try to insert all possible values (1-9)\n"," if possible(grid, y, x, n): # if you can insert n\n"," grid[y][x] = n # insert n to the grid\n"," if solve(grid): # Anything that is not None will return True here\n"," return grid # if successful, return the solved grid\n"," grid[y][x] = 0 # backtrack if it didn't work\n"," return None # no valid number found, trigger backtracking\n"," return grid # all positions filled, puzzle solved!"],"metadata":{"id":"0tQBuGiiwWd8","executionInfo":{"status":"ok","timestamp":1759759127282,"user_tz":240,"elapsed":9,"user":{"displayName":"Egemen Okte","userId":"05773821952504250534"}}},"execution_count":4,"outputs":[]},{"cell_type":"markdown","source":["##Step 3 - Solve the Grid!"],"metadata":{"id":"Fo8IgKkhvdUP"}},{"cell_type":"code","source":["#We can now pass the empty grid and solve it!\n","solved_grid = solve(grid)\n","solved_grid"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"RVAqNX4avaJ7","executionInfo":{"status":"ok","timestamp":1759759135034,"user_tz":240,"elapsed":34,"user":{"displayName":"Egemen Okte","userId":"05773821952504250534"}},"outputId":"2ce04499-7112-46f3-b426-2688a6d23098"},"execution_count":7,"outputs":[{"output_type":"execute_result","data":{"text/plain":["[[5, 3, 4, 6, 7, 8, 9, 1, 2],\n"," [6, 7, 2, 1, 9, 5, 3, 4, 8],\n"," [1, 9, 8, 3, 4, 2, 5, 6, 7],\n"," [8, 5, 9, 7, 6, 1, 4, 2, 3],\n"," [4, 2, 6, 8, 5, 3, 7, 9, 1],\n"," [7, 1, 3, 9, 2, 4, 8, 5, 6],\n"," [9, 6, 1, 5, 3, 7, 2, 8, 4],\n"," [2, 8, 7, 4, 1, 9, 6, 3, 5],\n"," [3, 4, 5, 2, 8, 6, 1, 7, 9]]"]},"metadata":{},"execution_count":7}]},{"cell_type":"code","source":["plot_sudoku(solved_grid) #this is one of the solutions!"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":806},"id":"V2YftijbyEvr","executionInfo":{"status":"ok","timestamp":1759759175800,"user_tz":240,"elapsed":647,"user":{"displayName":"Egemen Okte","userId":"05773821952504250534"}},"outputId":"d0e36600-a789-4daf-9d8a-b8f908d884fb"},"execution_count":11,"outputs":[{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}}]}]} --------------------------------------------------------------------------------