├── Linear_algebra ├── images │ ├── matrix-addition.png │ ├── vector-transposition.png │ ├── scalar-vector-matrix-tensor.png │ ├── square-matrix-transposition.png │ ├── dimensions-transposition-matrix.png │ └── non-squared-matrix-transposition.png ├── 1. Scalars, Vectors, Matrices, and Tensors.ipynb └── 01_Getting_started.ipynb └── README.md /Linear_algebra/images/matrix-addition.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/h9-tect/Linear_Algebra_tutorial/HEAD/Linear_algebra/images/matrix-addition.png -------------------------------------------------------------------------------- /Linear_algebra/images/vector-transposition.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/h9-tect/Linear_Algebra_tutorial/HEAD/Linear_algebra/images/vector-transposition.png -------------------------------------------------------------------------------- /Linear_algebra/images/scalar-vector-matrix-tensor.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/h9-tect/Linear_Algebra_tutorial/HEAD/Linear_algebra/images/scalar-vector-matrix-tensor.png -------------------------------------------------------------------------------- /Linear_algebra/images/square-matrix-transposition.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/h9-tect/Linear_Algebra_tutorial/HEAD/Linear_algebra/images/square-matrix-transposition.png -------------------------------------------------------------------------------- /Linear_algebra/images/dimensions-transposition-matrix.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/h9-tect/Linear_Algebra_tutorial/HEAD/Linear_algebra/images/dimensions-transposition-matrix.png -------------------------------------------------------------------------------- /Linear_algebra/images/non-squared-matrix-transposition.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/h9-tect/Linear_Algebra_tutorial/HEAD/Linear_algebra/images/non-squared-matrix-transposition.png -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Linear_Algebra_tutorial 2 | 3 | # هذه دورة في الجبر الخطي باللغتين الانجليزية والعربية للدمج بين الجبر الخطي ولغة Paython 4 | ## أول Notebook هي للمبتدئين تماما والذين ليس لديهم معرفة بلغة البرمجة وهي تشتمل على: 5 | - العلاقة بين المتغير والقيمة 6 | - العمليات على المتغيرات 7 | - استخدام مكتبة sympy للتعامل مع رموز الجبر الخطي بسهوله بداخل لغة البرمجة 8 | 9 | ## سيتم تحديث هذه notebook بشكل مستمر 10 | ## أود التنويه على أنها بشكل أساسي من مساق MIT 18.06 للفذ Gilbert Strange وبعض المصادر الاخرى التي سأضعها في نهاية الدورة كما سأضع مصادر الأكواد التي لم اكتبها بنفسي أيضا في النهاية 11 | -------------------------------------------------------------------------------- /Linear_algebra/1. Scalars, Vectors, Matrices, and Tensors.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 2, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import numpy as np" 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "$$\n", 17 | "\\newcommand\\bs[1]{\\boldsymbol{#1}}\n", 18 | "$$" 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": { 24 | "direction": "rtl" 25 | }, 26 | "source": [ 27 | "\n", 28 | "\n", 29 | "# مقدمة \n", 30 | "\n", 31 | "## هنا نستعرض المفاهيم الأساسية في الجبر الخطي وشرحها وأيضا معرفة مكتبة numpy سنستعرض المتجه Vector و المصفوفات matrices " 32 | ] 33 | }, 34 | { 35 | "cell_type": "markdown", 36 | "metadata": {}, 37 | "source": [ 38 | "# 2.1 Scalars, Vectors, Matrices and Tensors\n", 39 | "\n", 40 | "Let's start with some basic definitions:\n", 41 | "\n", 42 | "\"An\n", 43 | "Difference between a scalar, a vector, a matrix and a tensor\n", 44 | "\n", 45 | "- A scalar is a single number or a matrix with a single entry.\n", 46 | "- A vector is a 1-d array of numbers. Another way to think of vectors is identifying points in space with each element giving the coordinate along a different axis.\n", 47 | "\n", 48 | "$$\n", 49 | "\\bs{x} =\\begin{bmatrix}\n", 50 | " x_1 \\\\\\\\\n", 51 | " x_2 \\\\\\\\\n", 52 | " \\cdots \\\\\\\\\n", 53 | " x_n\n", 54 | "\\end{bmatrix}\n", 55 | "$$\n", 56 | "\n", 57 | "- A matrix is a 2-D array where each element is identified by two indices (ROW then COLUMN).\n", 58 | "\n", 59 | "$$\n", 60 | "\\bs{A}=\n", 61 | "\\begin{bmatrix}\n", 62 | " A_{1,1} & A_{1,2} & \\cdots & A_{1,n} \\\\\\\\\n", 63 | " A_{2,1} & A_{2,2} & \\cdots & A_{2,n} \\\\\\\\\n", 64 | " \\cdots & \\cdots & \\cdots & \\cdots \\\\\\\\\n", 65 | " A_{m,1} & A_{m,2} & \\cdots & A_{m,n}\n", 66 | "\\end{bmatrix}\n", 67 | "$$\n", 68 | "\n", 69 | "- A tensor is a $n$-dimensional array with $n>2$\n", 70 | "\n", 71 | "We will follow the conventions used in the [Deep Learning Book](http://www.deeplearningbook.org/):\n", 72 | "\n", 73 | "- scalars are written in lowercase and italics. For instance: $n$\n", 74 | "- vectors are written in lowercase, italics and bold type. For instance: $\\bs{x}$\n", 75 | "- matrices are written in uppercase, italics and bold. For instance: $\\bs{X}$" 76 | ] 77 | }, 78 | { 79 | "cell_type": "markdown", 80 | "metadata": {}, 81 | "source": [ 82 | "### Example 1.\n", 83 | "\n", 84 | "#### Create a vector with Python and Numpy\n", 85 | "\n", 86 | "*Coding tip*: Unlike the `matrix()` function which necessarily creates $2$-dimensional matrices, you can create $n$-dimensionnal arrays with the `array()` function. The main advantage to use `matrix()` is the useful methods (conjugate transpose, inverse, matrix operations...). We will use the `array()` function in this series.\n", 87 | "\n", 88 | "We will start by creating a vector. This is just a $1$-dimensional array:" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": 3, 94 | "metadata": {}, 95 | "outputs": [ 96 | { 97 | "data": { 98 | "text/plain": [ 99 | "array([1, 2, 3, 4])" 100 | ] 101 | }, 102 | "execution_count": 3, 103 | "metadata": {}, 104 | "output_type": "execute_result" 105 | } 106 | ], 107 | "source": [ 108 | "x = np.array([1, 2, 3, 4])\n", 109 | "x" 110 | ] 111 | }, 112 | { 113 | "cell_type": "markdown", 114 | "metadata": {}, 115 | "source": [ 116 | "### Example 2.\n", 117 | "\n", 118 | "#### Create a (3x2) matrix with nested brackets\n", 119 | "\n", 120 | "The `array()` function can also create $2$-dimensional arrays with nested brackets:" 121 | ] 122 | }, 123 | { 124 | "cell_type": "code", 125 | "execution_count": 4, 126 | "metadata": {}, 127 | "outputs": [ 128 | { 129 | "data": { 130 | "text/plain": [ 131 | "array([[1, 2],\n", 132 | " [3, 4],\n", 133 | " [5, 6]])" 134 | ] 135 | }, 136 | "execution_count": 4, 137 | "metadata": {}, 138 | "output_type": "execute_result" 139 | } 140 | ], 141 | "source": [ 142 | "A = np.array([[1, 2], [3, 4], [5, 6]])\n", 143 | "A" 144 | ] 145 | }, 146 | { 147 | "cell_type": "markdown", 148 | "metadata": {}, 149 | "source": [ 150 | "### Shape\n", 151 | "\n", 152 | "The shape of an array (that is to say its dimensions) tells you the number of values for each dimension. For a $2$-dimensional array it will give you the number of rows and the number of columns. Let's find the shape of our preceding $2$-dimensional array `A`. Since `A` is a Numpy array (it was created with the `array()` function) you can access its shape with:" 153 | ] 154 | }, 155 | { 156 | "cell_type": "code", 157 | "execution_count": 5, 158 | "metadata": {}, 159 | "outputs": [ 160 | { 161 | "data": { 162 | "text/plain": [ 163 | "(3, 2)" 164 | ] 165 | }, 166 | "execution_count": 5, 167 | "metadata": {}, 168 | "output_type": "execute_result" 169 | } 170 | ], 171 | "source": [ 172 | "A.shape" 173 | ] 174 | }, 175 | { 176 | "cell_type": "markdown", 177 | "metadata": {}, 178 | "source": [ 179 | "We can see that $\\bs{A}$ has 3 rows and 2 columns.\n", 180 | "\n", 181 | "Let's check the shape of our first vector:" 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": 6, 187 | "metadata": {}, 188 | "outputs": [ 189 | { 190 | "data": { 191 | "text/plain": [ 192 | "(4,)" 193 | ] 194 | }, 195 | "execution_count": 6, 196 | "metadata": {}, 197 | "output_type": "execute_result" 198 | } 199 | ], 200 | "source": [ 201 | "x.shape" 202 | ] 203 | }, 204 | { 205 | "cell_type": "markdown", 206 | "metadata": {}, 207 | "source": [ 208 | "As expected, you can see that $\\bs{x}$ has only one dimension. The number corresponds to the length of the array:" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": 7, 214 | "metadata": {}, 215 | "outputs": [ 216 | { 217 | "data": { 218 | "text/plain": [ 219 | "4" 220 | ] 221 | }, 222 | "execution_count": 7, 223 | "metadata": {}, 224 | "output_type": "execute_result" 225 | } 226 | ], 227 | "source": [ 228 | "len(x)" 229 | ] 230 | }, 231 | { 232 | "cell_type": "markdown", 233 | "metadata": {}, 234 | "source": [ 235 | "# Transposition\n", 236 | "\n", 237 | "With transposition you can convert a row vector to a column vector and vice versa:\n", 238 | "\n", 239 | "\"Transposition\n", 240 | "Vector transposition\n", 241 | "\n", 242 | "The transpose $\\bs{A}^{\\text{T}}$ of the matrix $\\bs{A}$ corresponds to the mirrored axes. If the matrix is a square matrix (same number of columns and rows):\n", 243 | "\n", 244 | "\"Transposition\n", 245 | "Square matrix transposition\n", 246 | "\n", 247 | "If the matrix is not square the idea is the same:\n", 248 | "\n", 249 | "\"Transposition\n", 250 | "Non-square matrix transposition\n", 251 | "\n", 252 | "\n", 253 | "The superscript $^\\text{T}$ is used for transposed matrices.\n", 254 | "\n", 255 | "$$\n", 256 | "\\bs{A}=\n", 257 | "\\begin{bmatrix}\n", 258 | " A_{1,1} & A_{1,2} \\\\\\\\\n", 259 | " A_{2,1} & A_{2,2} \\\\\\\\\n", 260 | " A_{3,1} & A_{3,2}\n", 261 | "\\end{bmatrix}\n", 262 | "$$\n", 263 | "\n", 264 | "$$\n", 265 | "\\bs{A}^{\\text{T}}=\n", 266 | "\\begin{bmatrix}\n", 267 | " A_{1,1} & A_{2,1} & A_{3,1} \\\\\\\\\n", 268 | " A_{1,2} & A_{2,2} & A_{3,2}\n", 269 | "\\end{bmatrix}\n", 270 | "$$\n", 271 | "\n", 272 | "The shape ($m \\times n$) is inverted and becomes ($n \\times m$).\n", 273 | "\n", 274 | "\"Dimensions\n", 275 | "Dimensions of matrix transposition" 276 | ] 277 | }, 278 | { 279 | "cell_type": "markdown", 280 | "metadata": {}, 281 | "source": [ 282 | "### Example 3.\n", 283 | "\n", 284 | "#### Create a matrix A and transpose it" 285 | ] 286 | }, 287 | { 288 | "cell_type": "code", 289 | "execution_count": 8, 290 | "metadata": {}, 291 | "outputs": [ 292 | { 293 | "data": { 294 | "text/plain": [ 295 | "array([[1, 2],\n", 296 | " [3, 4],\n", 297 | " [5, 6]])" 298 | ] 299 | }, 300 | "execution_count": 8, 301 | "metadata": {}, 302 | "output_type": "execute_result" 303 | } 304 | ], 305 | "source": [ 306 | "A = np.array([[1, 2], [3, 4], [5, 6]])\n", 307 | "A" 308 | ] 309 | }, 310 | { 311 | "cell_type": "code", 312 | "execution_count": 9, 313 | "metadata": {}, 314 | "outputs": [ 315 | { 316 | "data": { 317 | "text/plain": [ 318 | "array([[1, 3, 5],\n", 319 | " [2, 4, 6]])" 320 | ] 321 | }, 322 | "execution_count": 9, 323 | "metadata": {}, 324 | "output_type": "execute_result" 325 | } 326 | ], 327 | "source": [ 328 | "A_t = A.T\n", 329 | "A_t" 330 | ] 331 | }, 332 | { 333 | "cell_type": "markdown", 334 | "metadata": {}, 335 | "source": [ 336 | "We can check the dimensions of the matrices:" 337 | ] 338 | }, 339 | { 340 | "cell_type": "code", 341 | "execution_count": 10, 342 | "metadata": {}, 343 | "outputs": [ 344 | { 345 | "data": { 346 | "text/plain": [ 347 | "(3, 2)" 348 | ] 349 | }, 350 | "execution_count": 10, 351 | "metadata": {}, 352 | "output_type": "execute_result" 353 | } 354 | ], 355 | "source": [ 356 | "A.shape" 357 | ] 358 | }, 359 | { 360 | "cell_type": "code", 361 | "execution_count": 11, 362 | "metadata": {}, 363 | "outputs": [ 364 | { 365 | "data": { 366 | "text/plain": [ 367 | "(2, 3)" 368 | ] 369 | }, 370 | "execution_count": 11, 371 | "metadata": {}, 372 | "output_type": "execute_result" 373 | } 374 | ], 375 | "source": [ 376 | "A_t.shape" 377 | ] 378 | }, 379 | { 380 | "cell_type": "markdown", 381 | "metadata": {}, 382 | "source": [ 383 | "We can see that the number of columns becomes the number of rows with transposition and vice versa." 384 | ] 385 | }, 386 | { 387 | "cell_type": "markdown", 388 | "metadata": {}, 389 | "source": [ 390 | "# Addition\n", 391 | "\n", 392 | "\"Addition\n", 393 | "Addition of two matrices\n", 394 | "\n", 395 | "Matrices can be added if they have the same shape:\n", 396 | "\n", 397 | "$$\\bs{A} + \\bs{B} = \\bs{C}$$\n", 398 | "\n", 399 | "Each cell of $\\bs{A}$ is added to the corresponding cell of $\\bs{B}$:\n", 400 | "\n", 401 | "$$\\bs{A}_{i,j} + \\bs{B}_{i,j} = \\bs{C}_{i,j}$$\n", 402 | "\n", 403 | "$i$ is the row index and $j$ the column index.\n", 404 | "\n", 405 | "$$\n", 406 | "\\begin{bmatrix}\n", 407 | " A_{1,1} & A_{1,2} \\\\\\\\\n", 408 | " A_{2,1} & A_{2,2} \\\\\\\\\n", 409 | " A_{3,1} & A_{3,2}\n", 410 | "\\end{bmatrix}+\n", 411 | "\\begin{bmatrix}\n", 412 | " B_{1,1} & B_{1,2} \\\\\\\\\n", 413 | " B_{2,1} & B_{2,2} \\\\\\\\\n", 414 | " B_{3,1} & B_{3,2}\n", 415 | "\\end{bmatrix}=\n", 416 | "\\begin{bmatrix}\n", 417 | " A_{1,1} + B_{1,1} & A_{1,2} + B_{1,2} \\\\\\\\\n", 418 | " A_{2,1} + B_{2,1} & A_{2,2} + B_{2,2} \\\\\\\\\n", 419 | " A_{3,1} + B_{3,1} & A_{3,2} + B_{3,2}\n", 420 | "\\end{bmatrix}\n", 421 | "$$\n", 422 | "\n", 423 | "The shape of $\\bs{A}$, $\\bs{B}$ and $\\bs{C}$ are identical. Let's check that in an example:" 424 | ] 425 | }, 426 | { 427 | "cell_type": "markdown", 428 | "metadata": {}, 429 | "source": [ 430 | "### Example 4.\n", 431 | "\n", 432 | "#### Create two matrices A and B and add them\n", 433 | "\n", 434 | "With Numpy you can add matrices just as you would add vectors or scalars." 435 | ] 436 | }, 437 | { 438 | "cell_type": "code", 439 | "execution_count": 12, 440 | "metadata": {}, 441 | "outputs": [ 442 | { 443 | "data": { 444 | "text/plain": [ 445 | "array([[1, 2],\n", 446 | " [3, 4],\n", 447 | " [5, 6]])" 448 | ] 449 | }, 450 | "execution_count": 12, 451 | "metadata": {}, 452 | "output_type": "execute_result" 453 | } 454 | ], 455 | "source": [ 456 | "A = np.array([[1, 2], [3, 4], [5, 6]])\n", 457 | "A" 458 | ] 459 | }, 460 | { 461 | "cell_type": "code", 462 | "execution_count": 13, 463 | "metadata": {}, 464 | "outputs": [ 465 | { 466 | "data": { 467 | "text/plain": [ 468 | "array([[2, 5],\n", 469 | " [7, 4],\n", 470 | " [4, 3]])" 471 | ] 472 | }, 473 | "execution_count": 13, 474 | "metadata": {}, 475 | "output_type": "execute_result" 476 | } 477 | ], 478 | "source": [ 479 | "B = np.array([[2, 5], [7, 4], [4, 3]])\n", 480 | "B" 481 | ] 482 | }, 483 | { 484 | "cell_type": "code", 485 | "execution_count": 14, 486 | "metadata": {}, 487 | "outputs": [ 488 | { 489 | "data": { 490 | "text/plain": [ 491 | "array([[ 3, 7],\n", 492 | " [10, 8],\n", 493 | " [ 9, 9]])" 494 | ] 495 | }, 496 | "execution_count": 14, 497 | "metadata": {}, 498 | "output_type": "execute_result" 499 | } 500 | ], 501 | "source": [ 502 | "# Add matrices A and B\n", 503 | "C = A + B\n", 504 | "C" 505 | ] 506 | }, 507 | { 508 | "cell_type": "markdown", 509 | "metadata": {}, 510 | "source": [ 511 | "It is also possible to add a scalar to a matrix. This means adding this scalar to each cell of the matrix.\n", 512 | "\n", 513 | "$$\n", 514 | "\\alpha+ \\begin{bmatrix}\n", 515 | " A_{1,1} & A_{1,2} \\\\\\\\\n", 516 | " A_{2,1} & A_{2,2} \\\\\\\\\n", 517 | " A_{3,1} & A_{3,2}\n", 518 | "\\end{bmatrix}=\n", 519 | "\\begin{bmatrix}\n", 520 | " \\alpha + A_{1,1} & \\alpha + A_{1,2} \\\\\\\\\n", 521 | " \\alpha + A_{2,1} & \\alpha + A_{2,2} \\\\\\\\\n", 522 | " \\alpha + A_{3,1} & \\alpha + A_{3,2}\n", 523 | "\\end{bmatrix}\n", 524 | "$$" 525 | ] 526 | }, 527 | { 528 | "cell_type": "markdown", 529 | "metadata": {}, 530 | "source": [ 531 | "### Example 5.\n", 532 | "\n", 533 | "#### Add a scalar to a matrix" 534 | ] 535 | }, 536 | { 537 | "cell_type": "code", 538 | "execution_count": 15, 539 | "metadata": {}, 540 | "outputs": [ 541 | { 542 | "data": { 543 | "text/plain": [ 544 | "array([[1, 2],\n", 545 | " [3, 4],\n", 546 | " [5, 6]])" 547 | ] 548 | }, 549 | "execution_count": 15, 550 | "metadata": {}, 551 | "output_type": "execute_result" 552 | } 553 | ], 554 | "source": [ 555 | "A" 556 | ] 557 | }, 558 | { 559 | "cell_type": "code", 560 | "execution_count": 16, 561 | "metadata": {}, 562 | "outputs": [ 563 | { 564 | "data": { 565 | "text/plain": [ 566 | "array([[ 5, 6],\n", 567 | " [ 7, 8],\n", 568 | " [ 9, 10]])" 569 | ] 570 | }, 571 | "execution_count": 16, 572 | "metadata": {}, 573 | "output_type": "execute_result" 574 | } 575 | ], 576 | "source": [ 577 | "# Exemple: Add 4 to the matrix A\n", 578 | "C = A+4\n", 579 | "C" 580 | ] 581 | }, 582 | { 583 | "cell_type": "markdown", 584 | "metadata": {}, 585 | "source": [ 586 | "# Broadcasting\n", 587 | "\n", 588 | "Numpy can handle operations on arrays of different shapes. The smaller array will be extended to match the shape of the bigger one. The advantage is that this is done in `C` under the hood (like any vectorized operations in Numpy). Actually, we used broadcasting in the example 5. The scalar was converted in an array of same shape as $\\bs{A}$.\n", 589 | "\n", 590 | "Here is another generic example:\n", 591 | "\n", 592 | "$$\n", 593 | "\\begin{bmatrix}\n", 594 | " A_{1,1} & A_{1,2} \\\\\\\\\n", 595 | " A_{2,1} & A_{2,2} \\\\\\\\\n", 596 | " A_{3,1} & A_{3,2}\n", 597 | "\\end{bmatrix}+\n", 598 | "\\begin{bmatrix}\n", 599 | " B_{1,1} \\\\\\\\\n", 600 | " B_{2,1} \\\\\\\\\n", 601 | " B_{3,1}\n", 602 | "\\end{bmatrix}\n", 603 | "$$\n", 604 | "\n", 605 | "is equivalent to\n", 606 | "\n", 607 | "$$\n", 608 | "\\begin{bmatrix}\n", 609 | " A_{1,1} & A_{1,2} \\\\\\\\\n", 610 | " A_{2,1} & A_{2,2} \\\\\\\\\n", 611 | " A_{3,1} & A_{3,2}\n", 612 | "\\end{bmatrix}+\n", 613 | "\\begin{bmatrix}\n", 614 | " B_{1,1} & B_{1,1} \\\\\\\\\n", 615 | " B_{2,1} & B_{2,1} \\\\\\\\\n", 616 | " B_{3,1} & B_{3,1}\n", 617 | "\\end{bmatrix}=\n", 618 | "\\begin{bmatrix}\n", 619 | " A_{1,1} + B_{1,1} & A_{1,2} + B_{1,1} \\\\\\\\\n", 620 | " A_{2,1} + B_{2,1} & A_{2,2} + B_{2,1} \\\\\\\\\n", 621 | " A_{3,1} + B_{3,1} & A_{3,2} + B_{3,1}\n", 622 | "\\end{bmatrix}\n", 623 | "$$\n", 624 | "\n", 625 | "where the ($3 \\times 1$) matrix is converted to the right shape ($3 \\times 2$) by copying the first column. Numpy will do that automatically if the shapes can match." 626 | ] 627 | }, 628 | { 629 | "cell_type": "markdown", 630 | "metadata": {}, 631 | "source": [ 632 | "### Example 6.\n", 633 | "\n", 634 | "#### Add two matrices of different shapes" 635 | ] 636 | }, 637 | { 638 | "cell_type": "code", 639 | "execution_count": 17, 640 | "metadata": {}, 641 | "outputs": [ 642 | { 643 | "data": { 644 | "text/plain": [ 645 | "array([[1, 2],\n", 646 | " [3, 4],\n", 647 | " [5, 6]])" 648 | ] 649 | }, 650 | "execution_count": 17, 651 | "metadata": {}, 652 | "output_type": "execute_result" 653 | } 654 | ], 655 | "source": [ 656 | "A = np.array([[1, 2], [3, 4], [5, 6]])\n", 657 | "A" 658 | ] 659 | }, 660 | { 661 | "cell_type": "code", 662 | "execution_count": 18, 663 | "metadata": {}, 664 | "outputs": [ 665 | { 666 | "data": { 667 | "text/plain": [ 668 | "array([[2],\n", 669 | " [4],\n", 670 | " [6]])" 671 | ] 672 | }, 673 | "execution_count": 18, 674 | "metadata": {}, 675 | "output_type": "execute_result" 676 | } 677 | ], 678 | "source": [ 679 | "B = np.array([[2], [4], [6]])\n", 680 | "B" 681 | ] 682 | }, 683 | { 684 | "cell_type": "code", 685 | "execution_count": 19, 686 | "metadata": {}, 687 | "outputs": [ 688 | { 689 | "data": { 690 | "text/plain": [ 691 | "array([[ 3, 4],\n", 692 | " [ 7, 8],\n", 693 | " [11, 12]])" 694 | ] 695 | }, 696 | "execution_count": 19, 697 | "metadata": {}, 698 | "output_type": "execute_result" 699 | } 700 | ], 701 | "source": [ 702 | "# Broadcasting\n", 703 | "C=A+B\n", 704 | "C" 705 | ] 706 | }, 707 | { 708 | "cell_type": "markdown", 709 | "metadata": {}, 710 | "source": [ 711 | "You can find basics operations on matrices simply explained [here](https://www.mathsisfun.com/algebra/matrix-introduction.html)." 712 | ] 713 | }, 714 | { 715 | "cell_type": "markdown", 716 | "metadata": {}, 717 | "source": [ 718 | "*Coding tip*: Sometimes row or column vectors are not in proper shape for broadcasting. We need to imploy a trick ( a`numpy.newaxis` object) to help fix this issue." 719 | ] 720 | }, 721 | { 722 | "cell_type": "code", 723 | "execution_count": 20, 724 | "metadata": {}, 725 | "outputs": [ 726 | { 727 | "data": { 728 | "text/plain": [ 729 | "(4,)" 730 | ] 731 | }, 732 | "execution_count": 20, 733 | "metadata": {}, 734 | "output_type": "execute_result" 735 | } 736 | ], 737 | "source": [ 738 | "x = np.arange(4)\n", 739 | "x.shape" 740 | ] 741 | }, 742 | { 743 | "cell_type": "code", 744 | "execution_count": 21, 745 | "metadata": {}, 746 | "outputs": [ 747 | { 748 | "data": { 749 | "text/plain": [ 750 | "array([[0],\n", 751 | " [1],\n", 752 | " [2],\n", 753 | " [3]])" 754 | ] 755 | }, 756 | "execution_count": 21, 757 | "metadata": {}, 758 | "output_type": "execute_result" 759 | } 760 | ], 761 | "source": [ 762 | "# Adds a new dimension\n", 763 | "x[:, np.newaxis]" 764 | ] 765 | }, 766 | { 767 | "cell_type": "code", 768 | "execution_count": 22, 769 | "metadata": {}, 770 | "outputs": [ 771 | { 772 | "data": { 773 | "text/plain": [ 774 | "array([[-0.25008283, -1.64081586, 1.45475679],\n", 775 | " [-1.31953518, 0.11711513, -1.65276077],\n", 776 | " [ 0.47650016, 1.21744139, -0.5607036 ],\n", 777 | " [-0.3416611 , -0.94424699, -1.67540259]])" 778 | ] 779 | }, 780 | "execution_count": 22, 781 | "metadata": {}, 782 | "output_type": "execute_result" 783 | } 784 | ], 785 | "source": [ 786 | "A = np.random.randn(4,3)\n", 787 | "A" 788 | ] 789 | }, 790 | { 791 | "cell_type": "code", 792 | "execution_count": 23, 793 | "metadata": {}, 794 | "outputs": [ 795 | { 796 | "name": "stdout", 797 | "output_type": "stream", 798 | "text": [ 799 | "Operation cannot be completed. Dimension mismatch\n" 800 | ] 801 | } 802 | ], 803 | "source": [ 804 | "# This will throw an error\n", 805 | "try:\n", 806 | " A - x\n", 807 | "except ValueError:\n", 808 | " print(\"Operation cannot be completed. Dimension mismatch\") " 809 | ] 810 | }, 811 | { 812 | "cell_type": "code", 813 | "execution_count": 24, 814 | "metadata": {}, 815 | "outputs": [ 816 | { 817 | "data": { 818 | "text/plain": [ 819 | "array([[-0.25008283, -1.64081586, 1.45475679],\n", 820 | " [-2.31953518, -0.88288487, -2.65276077],\n", 821 | " [-1.52349984, -0.78255861, -2.5607036 ],\n", 822 | " [-3.3416611 , -3.94424699, -4.67540259]])" 823 | ] 824 | }, 825 | "execution_count": 24, 826 | "metadata": {}, 827 | "output_type": "execute_result" 828 | } 829 | ], 830 | "source": [ 831 | "# But this works -- subtract each column of A by the column vector x\n", 832 | "A - x[:, np.newaxis]" 833 | ] 834 | }, 835 | { 836 | "cell_type": "markdown", 837 | "metadata": {}, 838 | "source": [ 839 | "# References\n", 840 | "\n", 841 | "- [Broadcasting in Numpy](https://docs.scipy.org/doc/numpy-1.13.0/user/basics.broadcasting.html)\n", 842 | "\n", 843 | "- [Discussion on Arrays and matrices](https://stackoverflow.com/questions/4151128/what-are-the-differences-between-numpy-arrays-and-matrices-which-one-should-i-u)\n", 844 | "\n", 845 | "- [Math is fun - Matrix introduction](https://www.mathsisfun.com/algebra/matrix-introduction.html)" 846 | ] 847 | }, 848 | { 849 | "cell_type": "markdown", 850 | "metadata": {}, 851 | "source": [ 852 | "# Numpy\n", 853 | "\n", 854 | "- [arange](https://docs.scipy.org/doc/numpy/reference/generated/numpy.arange.html)\n", 855 | "- [Error Handling: try and except](https://www.pythonforbeginners.com/error-handling/python-try-and-except)\n", 856 | "- [Random.Randn](https://docs.scipy.org/doc/numpy/reference/generated/numpy.random.randn.html)" 857 | ] 858 | }, 859 | { 860 | "cell_type": "code", 861 | "execution_count": null, 862 | "metadata": {}, 863 | "outputs": [], 864 | "source": [] 865 | } 866 | ], 867 | "metadata": { 868 | "kernelspec": { 869 | "display_name": "Python 3 (ipykernel)", 870 | "language": "python", 871 | "name": "python3" 872 | }, 873 | "language_info": { 874 | "codemirror_mode": { 875 | "name": "ipython", 876 | "version": 3 877 | }, 878 | "file_extension": ".py", 879 | "mimetype": "text/x-python", 880 | "name": "python", 881 | "nbconvert_exporter": "python", 882 | "pygments_lexer": "ipython3", 883 | "version": "3.9.7" 884 | } 885 | }, 886 | "nbformat": 4, 887 | "nbformat_minor": 2 888 | } 889 | -------------------------------------------------------------------------------- /Linear_algebra/01_Getting_started.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Introduction to symbolic python\n", 8 | "\n", 9 | "# مقدمة للرموز باستخدام بايثون " 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "## هدف NoteBook " 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "هنا سنتعرف على مكتبة \"سيمباي\" والتي سنستخدمها في عرض الرموز المستخدمة خلال رحلتنا في الجبر الخطي " 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 4, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "# Importing\n", 33 | "from sympy import init_printing\n", 34 | "init_printing()" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "metadata": {}, 40 | "source": [ 41 | "## المتغيرات الرياضية mathmatical variables " 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "The equal symbol, `=`, is an assignment operator in Python. It assigns what is on the right-hand side (RHS) to what is on the left hand side (LHS). The name is basically a reference to a part of computer memory that stores what is on the RHS \n", 49 | "\n", 50 | "علامة = \"يساوي\" هي علامة التي تعطي قيمة للمتغير الموجود على الجانب الايمن والذي تخزنه في ذاكرة الكمبيوتلر لاستخدامه " 51 | ] 52 | }, 53 | { 54 | "cell_type": "markdown", 55 | "metadata": {}, 56 | "source": [ 57 | "Let's then create a computer variable named `number` and assign the valye $10$ to it.\n", 58 | "في لغة بايثون يمكن تخزين قيمة في متغير عن طريق علامة = كما في المثال التالي " 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": 64, 64 | "metadata": {}, 65 | "outputs": [], 66 | "source": [ 67 | "number = 10 # Creating a computer variable and assigning a value to it." 68 | ] 69 | }, 70 | { 71 | "cell_type": "markdown", 72 | "metadata": {}, 73 | "source": [ 74 | "A small part of the computer memory is now _called_ `number` and it contains the value $10$. We can access this value by simply calling the name of the computer variable.\n", 75 | "\n", 76 | "الان حجزنا جزء من الذاكرة وحجزنا فيه قيمة المتغير ويمكننا استدعائه بالطريقة التالية " 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": 6, 82 | "metadata": {}, 83 | "outputs": [ 84 | { 85 | "data": { 86 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAABsAAAASCAYAAACq26WdAAABbUlEQVR4nMXUv2tTURjG8U+Kk9JEF3HoUFpM3HQQf9CpEYJ0yuAq4mgFRXAQFEwFZ6WlHUWK/4CrSwZp6X9QNQQURZe2oK2IizqckxCOXm9D0vaFw3PPeV7O995z7vsWGo2G/YqRZH4FC3iNb/iNFzl7jOEZPuMn3uMpjqWJh5L5A5zGDj7hVA5oEqs4jpd4g3O4jcuYwmYnOf2yOyijiBs5IFiKoFuo4x6qeIIKHvcmp7AmWsLx5cUEasKxLSbeQ3zHVRzJgvUT1aiv8CvxtrGCw7gwDFgl6rsMvxW1PAxYKerXDL+zfnQYsLwoRO3e/yCwzpuXMvxikjcQ7G3UcoZ/Mmr3TgeBNaPW/rHPqFDQP7A2DFhb+O3HcTPx5oT6WhbqDX+3q3occCLqRTyPzxu425M/K7SreVzCOs5jWji++72bp7AzuJasTcQBHxJYG2fxSOiFM/gS4XPY+h+sEUc/8RHXd5O4l3V2sLA/Bl9BZgs2RoUAAAAASUVORK5CYII=\n", 87 | "text/latex": [ 88 | "$\\displaystyle 10$" 89 | ], 90 | "text/plain": [ 91 | "10" 92 | ] 93 | }, 94 | "execution_count": 6, 95 | "metadata": {}, 96 | "output_type": "execute_result" 97 | } 98 | ], 99 | "source": [ 100 | "number" 101 | ] 102 | }, 103 | { 104 | "cell_type": "markdown", 105 | "metadata": {}, 106 | "source": [ 107 | "The value $10$ is an instance of an object and as an object, is of a certain type. We can check up the object type with the `type()` function (a keyowrd from the Python syntax that actually perform a, well, _function_.). All functions in Python have a set of parenthesis at the end. Inside of these parenthesis we pass the information that the function required to do its job. These pieces of information are called _arguments_. We will pass `mnumber` as argument.\n", 108 | "\n", 109 | "\n", 110 | "لقسمة المتغير الذي وضعناه نوع خاص به فهو شئئ يمكننا معرفة نوعه من خلال الأمر الموجود بالاسفل \n", 111 | "هناك ملحوظة خاصة خاصة ببايثون ان الدوال في بايثون يأتي بعدها أقواس ويمكنك تمرير ما شئت خلال تلك الأقواس كما في المثل \n" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": 7, 117 | "metadata": {}, 118 | "outputs": [ 119 | { 120 | "data": { 121 | "text/plain": [ 122 | "int" 123 | ] 124 | }, 125 | "execution_count": 7, 126 | "metadata": {}, 127 | "output_type": "execute_result" 128 | } 129 | ], 130 | "source": [ 131 | "type(number)" 132 | ] 133 | }, 134 | { 135 | "cell_type": "markdown", 136 | "metadata": { 137 | "direction": "rtl" 138 | }, 139 | "source": [ 140 | "We note that it of type `int`, which is short for, _integer_, a whole number. We can reassign the computer variable to hold another value, which may be an instanceof another type of object.\n", 141 | "\n", 142 | "لاحظنا نوع المتغير هو int والذي هو اختصارا لـــ _integer_ والان سنحاول أن نعيد استخدام المتغير ليأخذ قيمة أخرى ونوع اخر \n", 143 | "\n", 144 | "int هي عدد صحيح يمكن كتابتها بدون استخدام الكسور أو الفواصل العشرية (3,2,1,........)" 145 | ] 146 | }, 147 | { 148 | "cell_type": "code", 149 | "execution_count": 66, 150 | "metadata": {}, 151 | "outputs": [ 152 | { 153 | "data": { 154 | "text/plain": [ 155 | "float" 156 | ] 157 | }, 158 | "execution_count": 66, 159 | "metadata": {}, 160 | "output_type": "execute_result" 161 | } 162 | ], 163 | "source": [ 164 | "number = 10.0 # The .0 indicates that this is a decimal value (we can also just type 10.)\n", 165 | "type(my_number)" 166 | ] 167 | }, 168 | { 169 | "cell_type": "markdown", 170 | "metadata": { 171 | "direction": "rtl" 172 | }, 173 | "source": [ 174 | "Our computer variable is now an instance of a floating point (`float`) object. We use the term _instance_, because in each case we create a single example of an object.\n", 175 | "\n", 176 | "هنا اختلف نوع المتغير لنوع(`float`) وهو الرقم الذي يأتي بعده رقم عشري أو كسور فالفاصلة العشرية تجعله float حتى إن كان بعد الفاصلة صفر " 177 | ] 178 | }, 179 | { 180 | "cell_type": "markdown", 181 | "metadata": {}, 182 | "source": [ 183 | "Computer variables and the assigment operator do not behave in the same way as their mathematical namesakes. Look at the code below." 184 | ] 185 | }, 186 | { 187 | "cell_type": "code", 188 | "execution_count": 72, 189 | "metadata": {}, 190 | "outputs": [], 191 | "source": [ 192 | "number =number + 1\n" 193 | ] 194 | }, 195 | { 196 | "cell_type": "code", 197 | "execution_count": 73, 198 | "metadata": {}, 199 | "outputs": [ 200 | { 201 | "data": { 202 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAC4AAAASCAYAAAAkAezhAAABmUlEQVR4nN3WvWsUQRgG8N+JNgYT00iKQDTBi11SBDVY5QJBrFLYinUiKIKFoOBFsFYSTBlE/AdshZBCFP8DP0JAQbSJAb8QG7WYmXBM2LssKbLnA8Oz877P7jw7OzPv1prNpm7Egax/EUt4jm/4iydt7i+r74RBrOATfuM9HqA/Fx7M+rcxhh/4iFMdBiqrb4cRvMQxPMUbnMY1nMc5fEnifMavo45ezO1isLL6dliOpq9iFjfRwH2M4l6rODe+hnXhk+8GZfVFGMaMsDQeZrk7+IlL6EnB3Ph+oRH5Gf5kue94gcM4m4JVMT4a+V1Bfj1yPQWqYrwv8teCfIofTYGqGO+EWuTtvVQV42lG+wryvZmuMsbfRq4X5E9G3t4DVTG+FnnGTk9HhOLzC69ScD+MjwgV9lBLbEM4Co/jSqZfEM7vx8J5jp0lfzY2GIg8iUfxehM39qCHVQzhhFBwEuaFkr+IabzGGUwJS+RW60Ny4+O4nMWGY4MPmZGy+nbYwATuCv8mF/A5vsgCtlrFtf/lt7Zr0LXG/wEbBVJ2Td7L9wAAAABJRU5ErkJggg==\n", 203 | "text/latex": [ 204 | "$\\displaystyle 11.0$" 205 | ], 206 | "text/plain": [ 207 | "11.0" 208 | ] 209 | }, 210 | "execution_count": 73, 211 | "metadata": {}, 212 | "output_type": "execute_result" 213 | } 214 | ], 215 | "source": [ 216 | "number" 217 | ] 218 | }, 219 | { 220 | "cell_type": "markdown", 221 | "metadata": { 222 | "direction": "rtl" 223 | }, 224 | "source": [ 225 | "Initially, this makes no sense. Just to be sure that we are all on the same page, let's create another computer variable called `x` and assign the integer value $7$ to it.\n", 226 | "\n", 227 | "هذه فقط مقدمة لكيفية تعيين قيمة لمتغير ما والذي سنحتاج المزيد منها في الدروس القادمة " 228 | ] 229 | }, 230 | { 231 | "cell_type": "code", 232 | "execution_count": 74, 233 | "metadata": {}, 234 | "outputs": [ 235 | { 236 | "data": { 237 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA0AAAASCAYAAACAa1QyAAAAuUlEQVR4nJ3QwW3CQBSE4Q/EIblBGUQpAEVwoYfklEickjZMGSAoAyiBq28pwKSMEA6sJcvZtQ0jrd5qnv7V7PSyLHOr+pX7An8t5xcGFSjHMvH4DHMcYlCegI5hruvxUnrGBD/YdYW+wtwKf2qDHvGOMzal2Qa9YehaQNEV+gxzVTWboCe84IR9V+hfAW3QAz5cC9jWlynoFaMQq6gvU1BZwDq2jEFjTEUKKDWIeN/oJRI0xmvUXdAFKJclWUUCPlgAAAAASUVORK5CYII=\n", 238 | "text/latex": [ 239 | "$\\displaystyle 7$" 240 | ], 241 | "text/plain": [ 242 | "7" 243 | ] 244 | }, 245 | "execution_count": 74, 246 | "metadata": {}, 247 | "output_type": "execute_result" 248 | } 249 | ], 250 | "source": [ 251 | "x = 7 # Creating a computer variable and assigning the integer value 7 to it\n", 252 | "x # Caling the computer variable to access the value that it holds" 253 | ] 254 | }, 255 | { 256 | "cell_type": "markdown", 257 | "metadata": {}, 258 | "source": [ 259 | "Now we'll repeat the ` + 1` we did above.\n", 260 | "\n", 261 | "\n", 262 | " كما فعلنا بالاعلى لنضف له ` + 1`\n", 263 | " \n" 264 | ] 265 | }, 266 | { 267 | "cell_type": "code", 268 | "execution_count": 75, 269 | "metadata": {}, 270 | "outputs": [ 271 | { 272 | "data": { 273 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAABN0lEQVR4nJ3TwSvlURjG8Y9pSpnsKGWh3JWNQikpUTaDyM7CllnYoTHLmx0L4Q+QhVm5RZKEWMjUWFiaxUgWFGpmM2VEyeL8ru49fiTP5u285/12zvs+55Rks1nv0YeUXDe2cI7/OMUyWl4Dp7CORmxiDkfowwEG84UfC6AqjOMK9bgu2OvALiaxFJ9Yk6x/RhDs4R8q0676G3doRkUEtqEcO2lX/YsJzOAYq/iDDHqxjS9pIMziDAsYKsifYLGwhXiqX5FLijL4hCbBku+YTgPbBTvWMJoU3wh29OMCY6iNwZ4k7nmuGxwm9Q0xWJrESunK5+9icD+Jw6iOoM9oxS1+UDzVnOBTJ35hBZeoS9oowTfBoiLwAV0YwYAwkDLB3w3MC49fDMK94OXsC30+Ke1bvUnvBh8BaHpBLKl33fAAAAAASUVORK5CYII=\n", 274 | "text/latex": [ 275 | "$\\displaystyle 8$" 276 | ], 277 | "text/plain": [ 278 | "8" 279 | ] 280 | }, 281 | "execution_count": 75, 282 | "metadata": {}, 283 | "output_type": "execute_result" 284 | } 285 | ], 286 | "source": [ 287 | "x = x + 1\n", 288 | "x" 289 | ] 290 | }, 291 | { 292 | "cell_type": "markdown", 293 | "metadata": {}, 294 | "source": [ 295 | "In mathematics, then, we are used to mathematical variables, such as $x$ and $y$ and not computer variables, `x` and `y`. We have to use a package such as `sympy` to help Python deal with this. More specifically, we import just the `symbols()` function from the `sympy` package. Note the syntaxh for doing so." 296 | ] 297 | }, 298 | { 299 | "cell_type": "code", 300 | "execution_count": 76, 301 | "metadata": {}, 302 | "outputs": [], 303 | "source": [ 304 | "from sympy import symbols" 305 | ] 306 | }, 307 | { 308 | "cell_type": "markdown", 309 | "metadata": {}, 310 | "source": [ 311 | "We now have the `symbols()` function added to the many built-in Python functions. We will use it to reassign our computer variable `x` and turn it into a mathematical variable." 312 | ] 313 | }, 314 | { 315 | "cell_type": "code", 316 | "execution_count": 77, 317 | "metadata": {}, 318 | "outputs": [ 319 | { 320 | "data": { 321 | "text/plain": [ 322 | "sympy.core.symbol.Symbol" 323 | ] 324 | }, 325 | "execution_count": 77, 326 | "metadata": {}, 327 | "output_type": "execute_result" 328 | } 329 | ], 330 | "source": [ 331 | "x = symbols('x') # Setting x as a mathematical symbol\n", 332 | "type(x) # Looking at the type of x" 333 | ] 334 | }, 335 | { 336 | "cell_type": "markdown", 337 | "metadata": {}, 338 | "source": [ 339 | "Now `x` is a mathematical symbol (in Python a `sympy.core.symbol.Symbol` object) and we can write an expression such as $x+1$." 340 | ] 341 | }, 342 | { 343 | "cell_type": "code", 344 | "execution_count": 78, 345 | "metadata": {}, 346 | "outputs": [ 347 | { 348 | "data": { 349 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAADIAAAASCAYAAAAZk42HAAABoElEQVR4nO3WP2gUQRTH8c9pSpGUdoKIaGNSKhiwUcFGEUFSiAEttBLFQCIRrlAQtDiwtPDEVJIyjVokIFhZaCEIIiRwoKCNIaRIcUnxRlyWvX9LXEPwCwPLm9nZ32/3vTdbq9frdgK7/rWAHlzEE7zFCjYwW7RwqEJRZZjBCFbRwuFOC6v4IhPiTZ4sce8tHMJe3Oi2MG/kdXrohVy8hmaae1hCUFkW8CU9tyt5I5No4z52Z+KPcQVPMbU1GreWvJGPeIEjuJxid3EbL3G9OmmDUVTsM7iEOvbgAV4JY+3KlA1IUbG30MB+0freiZpZ72O/JZHP2fEszS0UzDXLCs/Tqf3+yFxfxVqf+zUwnIuN4hyeC6NZPvS5b0+KjIyL4v6OfbipR+vL0CiITQgjTSwOqK9v8ql1Vry5TziKz7imy0G0XcgaOYE5USOnRXrdE1+tyrOjFL9TawTz+IVT+Jbic3gvUmNM/PNUyfk0iDSH4/40iZ+4Qxg5KNrrBs7ga26zabzBIxz7O3o7MioO4iwH0oBlyUjt/2/8NmPHGNkEizBQx91uUr4AAAAASUVORK5CYII=\n", 350 | "text/latex": [ 351 | "$\\displaystyle x + 1$" 352 | ], 353 | "text/plain": [ 354 | "x + 1" 355 | ] 356 | }, 357 | "execution_count": 78, 358 | "metadata": {}, 359 | "output_type": "execute_result" 360 | } 361 | ], 362 | "source": [ 363 | "x + 1" 364 | ] 365 | }, 366 | { 367 | "cell_type": "markdown", 368 | "metadata": {}, 369 | "source": [ 370 | "You might wonder what type `x+1` is. Certainly, `1` is a Python `int`." 371 | ] 372 | }, 373 | { 374 | "cell_type": "code", 375 | "execution_count": 79, 376 | "metadata": {}, 377 | "outputs": [ 378 | { 379 | "data": { 380 | "text/plain": [ 381 | "int" 382 | ] 383 | }, 384 | "execution_count": 79, 385 | "metadata": {}, 386 | "output_type": "execute_result" 387 | } 388 | ], 389 | "source": [ 390 | "type(1) # Checking the type of the mumber 1" 391 | ] 392 | }, 393 | { 394 | "cell_type": "code", 395 | "execution_count": 80, 396 | "metadata": {}, 397 | "outputs": [ 398 | { 399 | "data": { 400 | "text/plain": [ 401 | "sympy.core.add.Add" 402 | ] 403 | }, 404 | "execution_count": 80, 405 | "metadata": {}, 406 | "output_type": "execute_result" 407 | } 408 | ], 409 | "source": [ 410 | "type(x + 1) # Checking the type of x + 1" 411 | ] 412 | }, 413 | { 414 | "cell_type": "markdown", 415 | "metadata": {}, 416 | "source": [ 417 | "We note that its is a `sympy.core.add.Add` type. This allows Python to do the actual mathematical addition." 418 | ] 419 | }, 420 | { 421 | "cell_type": "markdown", 422 | "metadata": {}, 423 | "source": [ 424 | "Let's add `y` as a mathematical symbol and try to create $\\frac{x}{y}$. Here we are not using an assignment operator, we simply write the expression $\\frac{x}{y}$." 425 | ] 426 | }, 427 | { 428 | "cell_type": "code", 429 | "execution_count": 81, 430 | "metadata": {}, 431 | "outputs": [], 432 | "source": [ 433 | "y = symbols('y')" 434 | ] 435 | }, 436 | { 437 | "cell_type": "markdown", 438 | "metadata": {}, 439 | "source": [ 440 | "Just so that you know, the forward slash, `/`, symbol is used for division." 441 | ] 442 | }, 443 | { 444 | "cell_type": "code", 445 | "execution_count": 82, 446 | "metadata": {}, 447 | "outputs": [ 448 | { 449 | "data": { 450 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAACIAAAAWCAYAAAClrE55AAACMUlEQVR4nM3WS4iNcRjH8c+YSWLKwoLksqCYDRtigQXNmEgcZWEKCxaKcplcRkxnQRRJLgkpstNEQnLJQozFiCixoNko99vCPTMW//+pt9f7nmGMZn51+r/neZ//c77v83+e5z0VxWJRX1C/HoozFD+xv7dB5sdYZ3sbpIC3uNFTIFfQiYUpewVOxHu7UvcGYybOC8cDjdG3Med3x+GbBHgaZAM6sB2VCfseLMMxbE7tmYv+OJOw3Yzr1ByQAzH+6jyQ+ziFGiyJti1Yj9NYmRG0gE+4mrDdxRdMyfBfhFocwoM8ENiKryhG4h24HME6Ur4DUI9LcU9JP9CGkRiesA/CXrxCczJQFsgz7MNoIYWtQs18z/CtQ7XsbrkV1+TxNGMENuFjVyDwOnG9HJ9z/AoR8GIZkNLxjMc63MbJtHMWyGKhOF/E72tyICoxD9elni6qVeicUkYOxj2ror0syJxI+xAT8Bgr4tOkNQND5A+x93iESWjALBzBvSznJMg0tAg1UicczzZU+X12EOqmA+dyQAhtPDACvBEaIVMlkIm4IKS4Fs+jvQV3hBE+PbV3gZD+l2VASnVSjSa8KwcyVmjPTszG05RPU1x3J2yTherv6t3SHtc2HC/nWIUnGFbG55ow4pMqxLUrkNKkzizQpLr70isIU7i9jE+D0FWHhYyUVVU3QWpy7KMiwBgsFbpv458E7C5InuqxEx+Eblorfxj+V5Cj8fPX6qk/Rv+sPgPyC1sAdqT/WKiSAAAAAElFTkSuQmCC\n", 451 | "text/latex": [ 452 | "$\\displaystyle \\frac{x}{y}$" 453 | ], 454 | "text/plain": [ 455 | "x\n", 456 | "─\n", 457 | "y" 458 | ] 459 | }, 460 | "execution_count": 82, 461 | "metadata": {}, 462 | "output_type": "execute_result" 463 | } 464 | ], 465 | "source": [ 466 | "x / y # Stating a calculation without an assigment operator is an expression" 467 | ] 468 | }, 469 | { 470 | "cell_type": "markdown", 471 | "metadata": {}, 472 | "source": [ 473 | "The `sympy` package is great at creating mathematical typesetting. Let's create an expression with a power. In Python, two asterisks, `**`, are used to indicated powers. Below we create the expression $x^2 -x$." 474 | ] 475 | }, 476 | { 477 | "cell_type": "code", 478 | "execution_count": 83, 479 | "metadata": {}, 480 | "outputs": [ 481 | { 482 | "data": { 483 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAD4AAAAWCAYAAACYPi8fAAAB5ElEQVR4nO3XP2gUQRTH8U9iSm2sUgg2Fgqivf9QgwoWCnYB/4EWWgmCYAThBAshCqKQxsaglaTTRkktghZaKIIGLMQ/BAQtREQ9i9nAMW7Mzs1cOIlfGPZu9s3b39t583ZmoNVqWYoMZo4fw2N8wSzuYn2uqMUgN/DtmMAm7MQPTGNlpt+eM5Q5fk/0/xA+Y7Mw+31L7ozHrKh8firstzilA7+Kp3hU2G9xclO9k3Fsw1b8LOi3J8Qz/gBtHIj6B3Czunepxs8VHMYIXpeV2Jgk7XHgZ/ALF7Gso/8yjuAGzkZjruEgduBFlvQ8krTHgT/DLawTKjScw2ncwYnIfgJHMSoUtOGqLc8OI50k7QM1O7dVeIWPwtu6jvvYh++RbXseERfwh+NFoLH2uqr+VqjOq6uBD4V1EwdNWD91rbWAwDfCS2vabi/gL1n7fFV9tuP3MXxt+OCmzOBbgv27BNtG2usCHxXS5IOwXk/hZMKDmzBS2N8cjbXHqb4Xk3iODXiJ41jbI6ElSdLeGfgWTAnrZLeQMueFrKj7dvcTydrnAt+Ie8IBYxfeV/1TeIL9wo6sH+lK+yDWCCW/LZy2ZiKbseo6XlxyPl1rHxK2mMN/cT4tfKL6ka61lz6d/TP8D3yp8Rt4j4Nb181LiwAAAABJRU5ErkJggg==\n", 484 | "text/latex": [ 485 | "$\\displaystyle x^{2} - x$" 486 | ], 487 | "text/plain": [ 488 | " 2 \n", 489 | "x - x" 490 | ] 491 | }, 492 | "execution_count": 83, 493 | "metadata": {}, 494 | "output_type": "execute_result" 495 | } 496 | ], 497 | "source": [ 498 | "x**2 - x" 499 | ] 500 | }, 501 | { 502 | "cell_type": "markdown", 503 | "metadata": {}, 504 | "source": [ 505 | "## Transformation of expressions" 506 | ] 507 | }, 508 | { 509 | "cell_type": "markdown", 510 | "metadata": {}, 511 | "source": [ 512 | "Now we will get right into things and examine the power of `sympy`. One of the common tasks in algebra is factorization, as in $x^2 -x = x \\left( x - 1 \\right)$." 513 | ] 514 | }, 515 | { 516 | "cell_type": "markdown", 517 | "metadata": {}, 518 | "source": [ 519 | "Python functions that act on objects (or expressions) that we create are termed _methods_. The `.factor()` method is a function that will factor our expression." 520 | ] 521 | }, 522 | { 523 | "cell_type": "code", 524 | "execution_count": 84, 525 | "metadata": {}, 526 | "outputs": [ 527 | { 528 | "data": { 529 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAE4AAAAVCAYAAADo49gpAAACxklEQVR4nO3YTahVVRQH8N97NlAME2wQCBoRmhOVdKCgTfwCJ4oKIlRCChWkoSioKDxCS1AochDkxK+Bhg8MnNhEMIxIxRyIQUWi+ZGKouAHgdpgnaOb43nPc947Vy7aHw773v9e+7/PXXfttdfeHV1dXf5HfXQ2pLMLVzC4Ib12wQQ8xJJiRxOOm4h3sRm3G9BrJRZgG37ELeGUPb3Yn8ABbMTLaUcTjvs8e4lvGtBqNdbjE4zHhYpjvsBrWJ6S/XXcKEzHd7jbT61ngRXinYfg44pjfsFv+BADcrLouB9E+M4r8B3YkfVtTvgPsr59PUxaV6/VOIzfs3nrYC9GiCDBk45bjQdiTQ9I+K1YjO1Yk/DTcR8/9zBhXb12xdGsnZETRcedwm6MwXsZtw4rxXL8KLEdLHLFGT1vCnX02hnHsvadnHipxGg9FqJL7CSbcEj88AeJ3XARRZeeMmlVvXbGTdwTyxXlm8Pf+Aojxdb9k8hR/xbshmXtjadMWlWviLMiF1V9eisrmsB1vJp/KYs4uJp8XoI7JTb5LjqwwqRV9Ir4U/zLVXGxhm1fMEhSOZQ5bpFI3pdF/fKp8q37StYOK+nri14R0yrYPCt0Yij+SokUs7ETpzFW1C9L8VaJ2CURSaN7mbCOXjtjtCihfs2J1HFTsF/kpJnCKRtEVJbVWg9xRKz7N0v66+q1MyZl7eGcyJfqOBwUu8cMj3fK/TiOOZgqzngpujEfs/BHwvdVr9WYmz1E2oDJohiHa1hVMm6mqFe/z4lOES2HRATNEkk5xdqs3VIi2I1/8H7C9Uev1RgvCu/F4t3gjYRbUDLmFeHsgzifkx0N3MetFQf9t3Gyv2JtiGX4WhS/j1ZIE7cjX+IcPmtAq90wSARGt0JaacJx98Qp4Ljn7yLzdXyrJO/1VADXxZHsed5wRhwVn0BTV+cvHP4DevSygEEcLy8AAAAASUVORK5CYII=\n", 530 | "text/latex": [ 531 | "$\\displaystyle x \\left(x - 1\\right)$" 532 | ], 533 | "text/plain": [ 534 | "x⋅(x - 1)" 535 | ] 536 | }, 537 | "execution_count": 84, 538 | "metadata": {}, 539 | "output_type": "execute_result" 540 | } 541 | ], 542 | "source": [ 543 | "(x**2 - x).factor()" 544 | ] 545 | }, 546 | { 547 | "cell_type": "markdown", 548 | "metadata": {}, 549 | "source": [ 550 | "We can also expand an expression using the `expand()` method. By the way, we use the single asterisk, `*` symbol for multiplication." 551 | ] 552 | }, 553 | { 554 | "cell_type": "code", 555 | "execution_count": 85, 556 | "metadata": {}, 557 | "outputs": [ 558 | { 559 | "data": { 560 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAD4AAAAWCAYAAACYPi8fAAAB5ElEQVR4nO3XP2gUQRTH8U9iSm2sUgg2Fgqivf9QgwoWCnYB/4EWWgmCYAThBAshCqKQxsaglaTTRkktghZaKIIGLMQ/BAQtREQ9i9nAMW7Mzs1cOIlfGPZu9s3b39t583ZmoNVqWYoMZo4fw2N8wSzuYn2uqMUgN/DtmMAm7MQPTGNlpt+eM5Q5fk/0/xA+Y7Mw+31L7ozHrKh8firstzilA7+Kp3hU2G9xclO9k3Fsw1b8LOi3J8Qz/gBtHIj6B3Czunepxs8VHMYIXpeV2Jgk7XHgZ/ALF7Gso/8yjuAGzkZjruEgduBFlvQ8krTHgT/DLawTKjScw2ncwYnIfgJHMSoUtOGqLc8OI50k7QM1O7dVeIWPwtu6jvvYh++RbXseERfwh+NFoLH2uqr+VqjOq6uBD4V1EwdNWD91rbWAwDfCS2vabi/gL1n7fFV9tuP3MXxt+OCmzOBbgv27BNtG2usCHxXS5IOwXk/hZMKDmzBS2N8cjbXHqb4Xk3iODXiJ41jbI6ElSdLeGfgWTAnrZLeQMueFrKj7dvcTydrnAt+Ie8IBYxfeV/1TeIL9wo6sH+lK+yDWCCW/LZy2ZiKbseo6XlxyPl1rHxK2mMN/cT4tfKL6ka61lz6d/TP8D3yp8Rt4j4Nb181LiwAAAABJRU5ErkJggg==\n", 561 | "text/latex": [ 562 | "$\\displaystyle x^{2} - x$" 563 | ], 564 | "text/plain": [ 565 | " 2 \n", 566 | "x - x" 567 | ] 568 | }, 569 | "execution_count": 85, 570 | "metadata": {}, 571 | "output_type": "execute_result" 572 | } 573 | ], 574 | "source": [ 575 | "(x * (x - 1)).expand()" 576 | ] 577 | }, 578 | { 579 | "cell_type": "markdown", 580 | "metadata": {}, 581 | "source": [ 582 | "Just to be clear, we can import the actual functions, `factor()` and `expand()`, from `sympy`." 583 | ] 584 | }, 585 | { 586 | "cell_type": "code", 587 | "execution_count": 86, 588 | "metadata": {}, 589 | "outputs": [], 590 | "source": [ 591 | "from sympy import factor, expand" 592 | ] 593 | }, 594 | { 595 | "cell_type": "markdown", 596 | "metadata": {}, 597 | "source": [ 598 | "Now we can use them as functions (instead of the method syntax we used above)." 599 | ] 600 | }, 601 | { 602 | "cell_type": "code", 603 | "execution_count": 87, 604 | "metadata": {}, 605 | "outputs": [ 606 | { 607 | "data": { 608 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAE4AAAAVCAYAAADo49gpAAACxklEQVR4nO3YTahVVRQH8N97NlAME2wQCBoRmhOVdKCgTfwCJ4oKIlRCChWkoSioKDxCS1AochDkxK+Bhg8MnNhEMIxIxRyIQUWi+ZGKouAHgdpgnaOb43nPc947Vy7aHw773v9e+7/PXXfttdfeHV1dXf5HfXQ2pLMLVzC4Ib12wQQ8xJJiRxOOm4h3sRm3G9BrJRZgG37ELeGUPb3Yn8ABbMTLaUcTjvs8e4lvGtBqNdbjE4zHhYpjvsBrWJ6S/XXcKEzHd7jbT61ngRXinYfg44pjfsFv+BADcrLouB9E+M4r8B3YkfVtTvgPsr59PUxaV6/VOIzfs3nrYC9GiCDBk45bjQdiTQ9I+K1YjO1Yk/DTcR8/9zBhXb12xdGsnZETRcedwm6MwXsZtw4rxXL8KLEdLHLFGT1vCnX02hnHsvadnHipxGg9FqJL7CSbcEj88AeJ3XARRZeeMmlVvXbGTdwTyxXlm8Pf+Aojxdb9k8hR/xbshmXtjadMWlWviLMiF1V9eisrmsB1vJp/KYs4uJp8XoI7JTb5LjqwwqRV9Ir4U/zLVXGxhm1fMEhSOZQ5bpFI3pdF/fKp8q37StYOK+nri14R0yrYPCt0Yij+SokUs7ETpzFW1C9L8VaJ2CURSaN7mbCOXjtjtCihfs2J1HFTsF/kpJnCKRtEVJbVWg9xRKz7N0v66+q1MyZl7eGcyJfqOBwUu8cMj3fK/TiOOZgqzngpujEfs/BHwvdVr9WYmz1E2oDJohiHa1hVMm6mqFe/z4lOES2HRATNEkk5xdqs3VIi2I1/8H7C9Uev1RgvCu/F4t3gjYRbUDLmFeHsgzifkx0N3MetFQf9t3Gyv2JtiGX4WhS/j1ZIE7cjX+IcPmtAq90wSARGt0JaacJx98Qp4Ljn7yLzdXyrJO/1VADXxZHsed5wRhwVn0BTV+cvHP4DevSygEEcLy8AAAAASUVORK5CYII=\n", 609 | "text/latex": [ 610 | "$\\displaystyle x \\left(x - 1\\right)$" 611 | ], 612 | "text/plain": [ 613 | "x⋅(x - 1)" 614 | ] 615 | }, 616 | "execution_count": 87, 617 | "metadata": {}, 618 | "output_type": "execute_result" 619 | } 620 | ], 621 | "source": [ 622 | "factor(x**2 - x)" 623 | ] 624 | }, 625 | { 626 | "cell_type": "code", 627 | "execution_count": 88, 628 | "metadata": {}, 629 | "outputs": [ 630 | { 631 | "data": { 632 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAD4AAAAWCAYAAACYPi8fAAAB5ElEQVR4nO3XP2gUQRTH8U9iSm2sUgg2Fgqivf9QgwoWCnYB/4EWWgmCYAThBAshCqKQxsaglaTTRkktghZaKIIGLMQ/BAQtREQ9i9nAMW7Mzs1cOIlfGPZu9s3b39t583ZmoNVqWYoMZo4fw2N8wSzuYn2uqMUgN/DtmMAm7MQPTGNlpt+eM5Q5fk/0/xA+Y7Mw+31L7ozHrKh8firstzilA7+Kp3hU2G9xclO9k3Fsw1b8LOi3J8Qz/gBtHIj6B3Czunepxs8VHMYIXpeV2Jgk7XHgZ/ALF7Gso/8yjuAGzkZjruEgduBFlvQ8krTHgT/DLawTKjScw2ncwYnIfgJHMSoUtOGqLc8OI50k7QM1O7dVeIWPwtu6jvvYh++RbXseERfwh+NFoLH2uqr+VqjOq6uBD4V1EwdNWD91rbWAwDfCS2vabi/gL1n7fFV9tuP3MXxt+OCmzOBbgv27BNtG2usCHxXS5IOwXk/hZMKDmzBS2N8cjbXHqb4Xk3iODXiJ41jbI6ElSdLeGfgWTAnrZLeQMueFrKj7dvcTydrnAt+Ie8IBYxfeV/1TeIL9wo6sH+lK+yDWCCW/LZy2ZiKbseo6XlxyPl1rHxK2mMN/cT4tfKL6ka61lz6d/TP8D3yp8Rt4j4Nb181LiwAAAABJRU5ErkJggg==\n", 633 | "text/latex": [ 634 | "$\\displaystyle x^{2} - x$" 635 | ], 636 | "text/plain": [ 637 | " 2 \n", 638 | "x - x" 639 | ] 640 | }, 641 | "execution_count": 88, 642 | "metadata": {}, 643 | "output_type": "execute_result" 644 | } 645 | ], 646 | "source": [ 647 | "expand(x * (x - 1))" 648 | ] 649 | }, 650 | { 651 | "cell_type": "markdown", 652 | "metadata": {}, 653 | "source": [ 654 | "Lastly, we are still using Python, so we can assign any `sympy` expression to a computer variable and use all of the functions and methods we have learned about." 655 | ] 656 | }, 657 | { 658 | "cell_type": "code", 659 | "execution_count": 89, 660 | "metadata": {}, 661 | "outputs": [ 662 | { 663 | "data": { 664 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAE4AAAAVCAYAAADo49gpAAACxklEQVR4nO3YTahVVRQH8N97NlAME2wQCBoRmhOVdKCgTfwCJ4oKIlRCChWkoSioKDxCS1AochDkxK+Bhg8MnNhEMIxIxRyIQUWi+ZGKouAHgdpgnaOb43nPc947Vy7aHw773v9e+7/PXXfttdfeHV1dXf5HfXQ2pLMLVzC4Ib12wQQ8xJJiRxOOm4h3sRm3G9BrJRZgG37ELeGUPb3Yn8ABbMTLaUcTjvs8e4lvGtBqNdbjE4zHhYpjvsBrWJ6S/XXcKEzHd7jbT61ngRXinYfg44pjfsFv+BADcrLouB9E+M4r8B3YkfVtTvgPsr59PUxaV6/VOIzfs3nrYC9GiCDBk45bjQdiTQ9I+K1YjO1Yk/DTcR8/9zBhXb12xdGsnZETRcedwm6MwXsZtw4rxXL8KLEdLHLFGT1vCnX02hnHsvadnHipxGg9FqJL7CSbcEj88AeJ3XARRZeeMmlVvXbGTdwTyxXlm8Pf+Aojxdb9k8hR/xbshmXtjadMWlWviLMiF1V9eisrmsB1vJp/KYs4uJp8XoI7JTb5LjqwwqRV9Ir4U/zLVXGxhm1fMEhSOZQ5bpFI3pdF/fKp8q37StYOK+nri14R0yrYPCt0Yij+SokUs7ETpzFW1C9L8VaJ2CURSaN7mbCOXjtjtCihfs2J1HFTsF/kpJnCKRtEVJbVWg9xRKz7N0v66+q1MyZl7eGcyJfqOBwUu8cMj3fK/TiOOZgqzngpujEfs/BHwvdVr9WYmz1E2oDJohiHa1hVMm6mqFe/z4lOES2HRATNEkk5xdqs3VIi2I1/8H7C9Uev1RgvCu/F4t3gjYRbUDLmFeHsgzifkx0N3MetFQf9t3Gyv2JtiGX4WhS/j1ZIE7cjX+IcPmtAq90wSARGt0JaacJx98Qp4Ljn7yLzdXyrJO/1VADXxZHsed5wRhwVn0BTV+cvHP4DevSygEEcLy8AAAAASUVORK5CYII=\n", 665 | "text/latex": [ 666 | "$\\displaystyle x \\left(x - 1\\right)$" 667 | ], 668 | "text/plain": [ 669 | "x⋅(x - 1)" 670 | ] 671 | }, 672 | "execution_count": 89, 673 | "metadata": {}, 674 | "output_type": "execute_result" 675 | } 676 | ], 677 | "source": [ 678 | "my_expression = x * (x - 1) # Creating a computer variable\n", 679 | "my_expression" 680 | ] 681 | }, 682 | { 683 | "cell_type": "code", 684 | "execution_count": 90, 685 | "metadata": {}, 686 | "outputs": [ 687 | { 688 | "data": { 689 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAD4AAAAWCAYAAACYPi8fAAAB5ElEQVR4nO3XP2gUQRTH8U9iSm2sUgg2Fgqivf9QgwoWCnYB/4EWWgmCYAThBAshCqKQxsaglaTTRkktghZaKIIGLMQ/BAQtREQ9i9nAMW7Mzs1cOIlfGPZu9s3b39t583ZmoNVqWYoMZo4fw2N8wSzuYn2uqMUgN/DtmMAm7MQPTGNlpt+eM5Q5fk/0/xA+Y7Mw+31L7ozHrKh8firstzilA7+Kp3hU2G9xclO9k3Fsw1b8LOi3J8Qz/gBtHIj6B3Czunepxs8VHMYIXpeV2Jgk7XHgZ/ALF7Gso/8yjuAGzkZjruEgduBFlvQ8krTHgT/DLawTKjScw2ncwYnIfgJHMSoUtOGqLc8OI50k7QM1O7dVeIWPwtu6jvvYh++RbXseERfwh+NFoLH2uqr+VqjOq6uBD4V1EwdNWD91rbWAwDfCS2vabi/gL1n7fFV9tuP3MXxt+OCmzOBbgv27BNtG2usCHxXS5IOwXk/hZMKDmzBS2N8cjbXHqb4Xk3iODXiJ41jbI6ElSdLeGfgWTAnrZLeQMueFrKj7dvcTydrnAt+Ie8IBYxfeV/1TeIL9wo6sH+lK+yDWCCW/LZy2ZiKbseo6XlxyPl1rHxK2mMN/cT4tfKL6ka61lz6d/TP8D3yp8Rt4j4Nb181LiwAAAABJRU5ErkJggg==\n", 690 | "text/latex": [ 691 | "$\\displaystyle x^{2} - x$" 692 | ], 693 | "text/plain": [ 694 | " 2 \n", 695 | "x - x" 696 | ] 697 | }, 698 | "execution_count": 90, 699 | "metadata": {}, 700 | "output_type": "execute_result" 701 | } 702 | ], 703 | "source": [ 704 | "expand(my_expression)" 705 | ] 706 | }, 707 | { 708 | "cell_type": "markdown", 709 | "metadata": {}, 710 | "source": [ 711 | "## Common mathematical functions" 712 | ] 713 | }, 714 | { 715 | "cell_type": "markdown", 716 | "metadata": {}, 717 | "source": [ 718 | "The `sympy` package is really great for symbolic (mathematical) computation. In this section we higlight the difference between numerical (Python) and symbolic (`sympy`) computation. " 719 | ] 720 | }, 721 | { 722 | "cell_type": "markdown", 723 | "metadata": {}, 724 | "source": [ 725 | "As an example of numerical computation, let's calculate $\\frac{5}{3}$." 726 | ] 727 | }, 728 | { 729 | "cell_type": "code", 730 | "execution_count": 91, 731 | "metadata": {}, 732 | "outputs": [ 733 | { 734 | "data": { 735 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAMYAAAASCAYAAAAANKFkAAAC50lEQVR4nO3az6tVVRQH8M/TEh1EJaKCAxULKpRoUKD4C1EEhehJNoiCRuZUaCj1okF/gCNFZzoQbZT4IxTBHygOwgiDIOSFioSCaYIKWg32vnQ7nnt5Z997D1vcXzgs7l3f713fBW/xzjr7jE1MTCgoKPg/plU+f4hdOIt7+Af7B6yxCt/hJh7F+AM2DYnfliZXX6WXqfE/E/6e+11POuQXKuKdeBv3cR1v9GlgKtiJb3AbR6LpOXgHa3F0QH5bmlx9lV6mzr+Mr2tqEoZrHY51vqgOxg5hIH7DGpzu8UNTwdZo+iS24K9K/sUB+W1pcvWVosnVV4qmKf9yvOpwIcY9nS/G+uwYa4XBOIBPepF6YJowXPOwCLeGzG9Lk6uvFE2uvlI0KTV6YSl+xg0sFG+nqv8xhoUVWIzDuIPN0cBDXPLfhKby29Lk6qv00rxGL3we4z59doxh4d0Y/8CPWFbJnxEW/VuJ/LY0ufoqvTSvUYdZwt3Q39jbnag+lRoW5sa4PRZfj5eEqT6B1Tg0AL8tTa6+Si/Na9ThI7wiLN3XuhOjGozpMY4Jk3tKeNJ1BePCgr8GyxP5bWly9VV6aV6jDtti3F1NjGow7sR4FT9Vcg+EqYb3EvltaXL1laLJ1VeKJqVGFW8Ju8p1NY+ORzUYv8b4Z498p7FZify2NLn6StHk6itFk1Kjitqlu4NRDcYZPMbrmFGTXxrjZCK/LU2uvlI0ufpK0aTU6MZMfCos3fvqCIMOxhLhdLx6mHIbB/EyvqzkNmAj7uJ4Ir8tTa6+Si/Na3RjK14VbqGu1RGqB3wfxAvmxwJXhXenOoa+6OJPCociiz09nXNxHq9F/aXIHRfeS/nY008amvDb0uTqq/TSvEYHZ7ES7+P7OkJ1MCbwVY8fg9+Fk8YOJvUeDJgtvM8yjgXCsf05fIuLQ+C3pcnVV+mleY038YuwdC9Ss1/Q/5WQgoLnFqNavgsKnmmUwSgoqMG/nmkEBpbjM9MAAAAASUVORK5CYII=\n", 736 | "text/latex": [ 737 | "$\\displaystyle 1.66666666666667$" 738 | ], 739 | "text/plain": [ 740 | "1.6666666666666667" 741 | ] 742 | }, 743 | "execution_count": 91, 744 | "metadata": {}, 745 | "output_type": "execute_result" 746 | } 747 | ], 748 | "source": [ 749 | "5 / 3" 750 | ] 751 | }, 752 | { 753 | "cell_type": "markdown", 754 | "metadata": {}, 755 | "source": [ 756 | "We get an approximation, i.e. the reciprocal $6$ is terminated by rouding to a $7$. The real solution is obviously $1.\\dot{6}$. Better yet, the exact solution is $\\frac{5}{3}$.." 757 | ] 758 | }, 759 | { 760 | "cell_type": "markdown", 761 | "metadata": {}, 762 | "source": [ 763 | "There is package called `math` that expands Python's ability to do numerical computations. Let's import it and calculate the square root of eight." 764 | ] 765 | }, 766 | { 767 | "cell_type": "code", 768 | "execution_count": 92, 769 | "metadata": {}, 770 | "outputs": [], 771 | "source": [ 772 | "import math" 773 | ] 774 | }, 775 | { 776 | "cell_type": "markdown", 777 | "metadata": {}, 778 | "source": [ 779 | "Because we did not import any specific `math` functions, we have to refer to them by dot notation, i.e. `math.sqrt()` for the square root function in the `math` function." 780 | ] 781 | }, 782 | { 783 | "cell_type": "code", 784 | "execution_count": 93, 785 | "metadata": {}, 786 | "outputs": [ 787 | { 788 | "data": { 789 | "image/png": "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\n", 790 | "text/latex": [ 791 | "$\\displaystyle 2.82842712474619$" 792 | ], 793 | "text/plain": [ 794 | "2.8284271247461903" 795 | ] 796 | }, 797 | "execution_count": 93, 798 | "metadata": {}, 799 | "output_type": "execute_result" 800 | } 801 | ], 802 | "source": [ 803 | "math.sqrt(8) # An approxximation of the square root of 8" 804 | ] 805 | }, 806 | { 807 | "cell_type": "markdown", 808 | "metadata": {}, 809 | "source": [ 810 | "The `math` package contains numerical approximations of constants such as $\\pi$." 811 | ] 812 | }, 813 | { 814 | "cell_type": "code", 815 | "execution_count": 94, 816 | "metadata": {}, 817 | "outputs": [ 818 | { 819 | "data": { 820 | "image/png": "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\n", 821 | "text/latex": [ 822 | "$\\displaystyle 3.14159265358979$" 823 | ], 824 | "text/plain": [ 825 | "3.141592653589793" 826 | ] 827 | }, 828 | "execution_count": 94, 829 | "metadata": {}, 830 | "output_type": "execute_result" 831 | } 832 | ], 833 | "source": [ 834 | "math.pi" 835 | ] 836 | }, 837 | { 838 | "cell_type": "markdown", 839 | "metadata": {}, 840 | "source": [ 841 | "The `exp()` function contains an approximation of Euler's number. We can get this approximation by passing the argument `1`, as in $e^1 = e$." 842 | ] 843 | }, 844 | { 845 | "cell_type": "code", 846 | "execution_count": 95, 847 | "metadata": {}, 848 | "outputs": [ 849 | { 850 | "data": { 851 | "image/png": "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\n", 852 | "text/latex": [ 853 | "$\\displaystyle 2.71828182845905$" 854 | ], 855 | "text/plain": [ 856 | "2.718281828459045" 857 | ] 858 | }, 859 | "execution_count": 95, 860 | "metadata": {}, 861 | "output_type": "execute_result" 862 | } 863 | ], 864 | "source": [ 865 | "math.exp(1)" 866 | ] 867 | }, 868 | { 869 | "cell_type": "markdown", 870 | "metadata": {}, 871 | "source": [ 872 | "Since we are dealing with approximations when doing numerical calculations, we have to deal with a bit of rounding. Here is $\\sin \\left( \\frac{\\pi}{6} \\right) = 0.5 $." 873 | ] 874 | }, 875 | { 876 | "cell_type": "code", 877 | "execution_count": 96, 878 | "metadata": {}, 879 | "outputs": [ 880 | { 881 | "data": { 882 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAACEAAAASCAYAAADVCrdsAAAB30lEQVR4nM3Vz4tOURgH8M+IqDcGC1mIlzdDSVLyI6VQk1hZ2LGwE0WyURbeV9lJ8is2lPEP2FBqmkbIWsqvxkwppMhkJAvG4pyr67h35l4K37p97316ztP3POc539vVbrf9a0wpiC3AFbzCF4zgDObUrD2C8ZLnTT5xarKwhfuYhxt4grU4hG3YiHc1hIwKG0gxNpGIi1HAQZzLxU/jME5iXw0RH9CeLCl/HEvQK7TxQpJ3HJ+wB40aIioh34ktkW/jW5L3EfeiyPXor1h/OnZjobCJh7iDr2UilkV+VlLweRTRU0PEfPQlsWHsxWAWyB9Hd+TRkoJZfHZFAVexNQppYCUuo4lbWJUlpoM5Eboij1fM7yTfj4ShHsMRYWB38nMnsp12K8asJO93cSnypiyQF/E0ck/J4qWRy2amKt5G/nHL8iIGIvf61UlnCkb1GQ/+UMSGyC+KRAwJ17OJA8nCjqD8mnDVMrSwHNOS/BWYWyBgEc7H9+tZMB3M/YJtnxUm+zHWYbNwDMeS/P5YeLFgchl24ajQ3WHBZ1rYgRm4iVNlIoawBieEf8V2vI6iOnhfsLsiDAi+s1pof0Ow8LuCb/TJ3bKiK/pSMJMqaJbEB+XMaDIU/cr/Ov4LEd8BzBZe2cC/SL8AAAAASUVORK5CYII=\n", 883 | "text/latex": [ 884 | "$\\displaystyle 0.5$" 885 | ], 886 | "text/plain": [ 887 | "0.49999999999999994" 888 | ] 889 | }, 890 | "execution_count": 96, 891 | "metadata": {}, 892 | "output_type": "execute_result" 893 | } 894 | ], 895 | "source": [ 896 | "math.sin(math.pi/6)" 897 | ] 898 | }, 899 | { 900 | "cell_type": "markdown", 901 | "metadata": {}, 902 | "source": [ 903 | "The `log()` function in the `math` package calculates the natural logarith. The naural logarithm of Euler's number is $1$." 904 | ] 905 | }, 906 | { 907 | "cell_type": "code", 908 | "execution_count": 97, 909 | "metadata": {}, 910 | "outputs": [ 911 | { 912 | "data": { 913 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAACEAAAASCAYAAADVCrdsAAABdklEQVR4nM3VzUtUURzG8c+IbRRnaiMtBN9wpl0tpBJXTiDiahZuo7UFRdBCMGgUWhdFLUWif8CtELOIov/ANwSFyI0FpRFtssU5F4ajU4vxog8cnnvP73fv/d5zuc8p1Ot1Z62O5HwGL/EeP3CEt23cvw9L+ILf2MFzXGpu6kwueoyrOMRnXGkDYBgf0YsVrOM6HmAK4/jK8ZV4iDKKmG0DAF5HgPuoYQ5VPEMFT7PGFKKBLeEztKMhTArL/yqpPcFP3Eb3SRCnpWr0VfxJagf4gC7czBOiEn2zRX0rejlPiFL07y3q2fzFPCH+p0L0ozwhsjcttagXm/vygtiIXm5RH4m+mSdEI/rkCc/oEYLqFz6dBsSwkKoXkvlt4fccwL2ktiDkwxshL47Fdi0OuBx9DMvxeB+PmvrfoR+DQjA1664Q2y9wC2u4gQnhM8xnjSnENdxJ5obigN0E4l/axigWhb1iGnsRagHfssbCedzKz0TnAuIvbkJCzMV2+QQAAAAASUVORK5CYII=\n", 914 | "text/latex": [ 915 | "$\\displaystyle 1.0$" 916 | ], 917 | "text/plain": [ 918 | "1.0" 919 | ] 920 | }, 921 | "execution_count": 97, 922 | "metadata": {}, 923 | "output_type": "execute_result" 924 | } 925 | ], 926 | "source": [ 927 | "math.log(math.exp(1))" 928 | ] 929 | }, 930 | { 931 | "cell_type": "markdown", 932 | "metadata": {}, 933 | "source": [ 934 | "Now, let's change to symbolic computation and import some useful functions from `sympy`." 935 | ] 936 | }, 937 | { 938 | "cell_type": "code", 939 | "execution_count": 98, 940 | "metadata": {}, 941 | "outputs": [], 942 | "source": [ 943 | "from sympy import Rational, sqrt, log, exp, sin, pi, I" 944 | ] 945 | }, 946 | { 947 | "cell_type": "markdown", 948 | "metadata": {}, 949 | "source": [ 950 | "The `Rational()` function calculates an exact solution for fraction. Here is $\\frac{5}{3}$ again." 951 | ] 952 | }, 953 | { 954 | "cell_type": "code", 955 | "execution_count": 99, 956 | "metadata": {}, 957 | "outputs": [ 958 | { 959 | "data": { 960 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAACEAAAAUCAYAAAADU1RxAAACKklEQVR4nM3VX2iOYRgG8N9GTBNCtiSKhHYgoiyacrBWEt/KmQMOSDhRO8CJOVBEaDmQE2WOHFiSPzW2hhxa1jhQjHayTf41/1LDwfN89e7b+359mxVXfd3ve333cz/X87z3cz1lzc3N/jXKC97f4HfGb6BInSqMoCXBncYD9OM7PqAbxzEvOXhqSsHPuJDCfykiYruwoLYEdxhP0Y4hVGIDmrEvPvdnifgUE8eDHN7jYYKbhR8puSdxDEdxgLGfYyKYjS24JXySPNIEwPUYl+eJtJ2Yjl1YjK/oEVY4kpILWzENN0oUvS3GnmIiqtFawPVhD7pS8nNRbHvGpE2YKezYOmyKAk5libiCR3iOYSzFIaGR7qIWzxL5FWiI/2Vtf5NwevK4h914lycKe+IEOjCIb+jFfpzDDGMbtj6usk02qlEWY2NcWDfWZonIwqUY6wr4HH7idgk1BqPYesEnro5XxFCMlQluitBkHYK3lIq3eIEazB+PiNoYXye4OmFFxT5FFhbGOFIoogZzUwYswcX4fC3BN+IXbqaMWSn0QCHKBbNagCf4yOjTsRNH0CkcyWEsE3ygAndwNpG/IxYaTJmsAWcEf3kluGkVNguNOYC9+eSkiE6swBph+ysFC38s+EarcJHBeizC+RQBcB+XsRGrMUfwkpexTotwoY0R0SXdjNKQizGrH3pxsMRaE747coJp9U1w/Cik2XYpWDUZk+cxGbfoX+O/EPEHDkF0z4zTY9oAAAAASUVORK5CYII=\n", 961 | "text/latex": [ 962 | "$\\displaystyle \\frac{5}{3}$" 963 | ], 964 | "text/plain": [ 965 | "5/3" 966 | ] 967 | }, 968 | "execution_count": 99, 969 | "metadata": {}, 970 | "output_type": "execute_result" 971 | } 972 | ], 973 | "source": [ 974 | "# Because we imported the function directly, we don't have to use the dot notation\n", 975 | "Rational(5, 3)" 976 | ] 977 | }, 978 | { 979 | "cell_type": "markdown", 980 | "metadata": {}, 981 | "source": [ 982 | "The `evalf()` method still allows us to get a numerical approximation." 983 | ] 984 | }, 985 | { 986 | "cell_type": "code", 987 | "execution_count": 100, 988 | "metadata": {}, 989 | "outputs": [ 990 | { 991 | "data": { 992 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAMYAAAASCAYAAAAANKFkAAAC50lEQVR4nO3az6tVVRQH8M/TEh1EJaKCAxULKpRoUKD4C1EEhehJNoiCRuZUaCj1okF/gCNFZzoQbZT4IxTBHygOwgiDIOSFioSCaYIKWg32vnQ7nnt5Z997D1vcXzgs7l3f713fBW/xzjr7jE1MTCgoKPg/plU+f4hdOIt7+Af7B6yxCt/hJh7F+AM2DYnfliZXX6WXqfE/E/6e+11POuQXKuKdeBv3cR1v9GlgKtiJb3AbR6LpOXgHa3F0QH5bmlx9lV6mzr+Mr2tqEoZrHY51vqgOxg5hIH7DGpzu8UNTwdZo+iS24K9K/sUB+W1pcvWVosnVV4qmKf9yvOpwIcY9nS/G+uwYa4XBOIBPepF6YJowXPOwCLeGzG9Lk6uvFE2uvlI0KTV6YSl+xg0sFG+nqv8xhoUVWIzDuIPN0cBDXPLfhKby29Lk6qv00rxGL3we4z59doxh4d0Y/8CPWFbJnxEW/VuJ/LY0ufoqvTSvUYdZwt3Q39jbnag+lRoW5sa4PRZfj5eEqT6B1Tg0AL8tTa6+Si/Na9ThI7wiLN3XuhOjGozpMY4Jk3tKeNJ1BePCgr8GyxP5bWly9VV6aV6jDtti3F1NjGow7sR4FT9Vcg+EqYb3EvltaXL1laLJ1VeKJqVGFW8Ju8p1NY+ORzUYv8b4Z498p7FZify2NLn6StHk6itFk1Kjitqlu4NRDcYZPMbrmFGTXxrjZCK/LU2uvlI0ufpK0aTU6MZMfCos3fvqCIMOxhLhdLx6mHIbB/EyvqzkNmAj7uJ4Ir8tTa6+Si/Na3RjK14VbqGu1RGqB3wfxAvmxwJXhXenOoa+6OJPCociiz09nXNxHq9F/aXIHRfeS/nY008amvDb0uTqq/TSvEYHZ7ES7+P7OkJ1MCbwVY8fg9+Fk8YOJvUeDJgtvM8yjgXCsf05fIuLQ+C3pcnVV+mleY038YuwdC9Ss1/Q/5WQgoLnFqNavgsKnmmUwSgoqMG/nmkEBpbjM9MAAAAASUVORK5CYII=\n", 993 | "text/latex": [ 994 | "$\\displaystyle 1.66666666666667$" 995 | ], 996 | "text/plain": [ 997 | "1.66666666666667" 998 | ] 999 | }, 1000 | "execution_count": 100, 1001 | "metadata": {}, 1002 | "output_type": "execute_result" 1003 | } 1004 | ], 1005 | "source": [ 1006 | "(Rational(5, 3)).evalf()" 1007 | ] 1008 | }, 1009 | { 1010 | "cell_type": "markdown", 1011 | "metadata": {}, 1012 | "source": [ 1013 | "We can even specify the number of significant digits we require by passing it as an argument." 1014 | ] 1015 | }, 1016 | { 1017 | "cell_type": "code", 1018 | "execution_count": 101, 1019 | "metadata": {}, 1020 | "outputs": [ 1021 | { 1022 | "data": { 1023 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAC0AAAASCAYAAADPNlfiAAACB0lEQVR4nN3WTYiNURzH8c8MI7MQSrITUmiEBWZkjESKjZGxELHxsiU7k0YWsrYymbKwEXbGWyY1FjQLjYWFkkYzEqbGW17yujjnMU9nnntH3bmL8avT/7nnd57/+d5zn///uTUdHR0mm2qTz7twDvfxAb9xqcI9mnENr/AtxjvYlltzIO5VbvzMFk9NNmjHCnzCEJZUCNyO0xjG9Qg8B6uwETfiun6cKpGjGZtwsxT00Qj7DC24VwFwWwS+i534mPh1uev+OIr0IMbObCKFrgQyr1qcxWfsMRYYvv9DngY04iW6s8kUeqK0DgtwFSPYHgG+os/o6Y2nwzF2KfNMT5RWx/gaj7A88XuFon9bJkc99uIXLuSNtHtMlObGeCRuvhkzhNO+jQ24Mk6O3ZglFOBg3qgW9JQYa4QT7RE60hO0CsXegqYyOQ7FeD41qgU9EuNzPE68L8Jpw5oS9y8T6mLIaFv8q2pBP43xXQk/+1L1JfzCAsxULehe/MBiTCvwG2IcKPCmY59QgF1FySuFXiS8NeuS+WFcxkycTLwt2Ir3uFWQsw2zhcdisMAf0/J2xAHzYmzCxRzM8dz6HswXevJAkusY1uKE0C364tpW4Sc/qPjxyQqws8ArhF6J/cncwjjgRQJdTm8idHsEbRTejN04g4cF9yzFeiUKMFPN//DXdFJoUkL/AfVucSB7Q1orAAAAAElFTkSuQmCC\n", 1024 | "text/latex": [ 1025 | "$\\displaystyle 1.67$" 1026 | ], 1027 | "text/plain": [ 1028 | "1.67" 1029 | ] 1030 | }, 1031 | "execution_count": 101, 1032 | "metadata": {}, 1033 | "output_type": "execute_result" 1034 | } 1035 | ], 1036 | "source": [ 1037 | "(Rational(5, 3)).evalf(3) # Significant digits" 1038 | ] 1039 | }, 1040 | { 1041 | "cell_type": "markdown", 1042 | "metadata": {}, 1043 | "source": [ 1044 | "Now for the square root of $8$." 1045 | ] 1046 | }, 1047 | { 1048 | "cell_type": "code", 1049 | "execution_count": 102, 1050 | "metadata": {}, 1051 | "outputs": [ 1052 | { 1053 | "data": { 1054 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAACwAAAAbCAYAAAAH+20UAAAB9klEQVR4nO3Xz4tNYRzH8dc1YyUbk6wtqCn/wFjdSY1fRZGFBRbslJSFUlM3WdhJKRYWVnbS0DBjQTeilFIkZCEpk1B+RDGGxfPg3Dv3nHuOc05S86nTeXrOcz6f9/me53nOvY1Wq+V/0qJ/DVBUgzX7L8WHKg3rrvB6bECjqqNu4CZuVGlYJ/BAPL5WaVon8Frcrtq0TuBNuFK1aZ3AQ3hbtWkSeAj7cBHP8AXvcQt7FXu4VXiScq1UTnIf3oHTeCWs7BdYgW04i41xzI8cwFtwOeVaqZwk8NMYNIm5RP8R3MX2aHohB/Dq6NdLpXKS5b8uVGWua8wMzsR2s+veY0JFklome+4WzUkFztK3eJ5N9I1hRHh9SZXZHXrldCjPb4lB7I7tqUT/lFCVa8KD/6rYCM4XwszO6VCeCh/HGqFq013X7uOz8JGAxfhu/uvOo6yc3+oHfACH8Bi7UsZcwtbYbqJdhLJADrKB9+MkHmEU71LGTfgDPCajOiVzkA58EKfwMJrMZHi0sRzDWIJPBWCL5KA38GGcEObnKF738ZgV5t04HuRGLZ6D+cDjwuS/h3V4kzN8Ajulf9269bc5HdvaHhwVVvlNYSF06znO9ei/ijt4mSOzTE4H8Mp4HhDmVi+1U4w+YnMf0CpyNBb+5tesBeC69RO2FYRPmvfOKgAAAABJRU5ErkJggg==\n", 1055 | "text/latex": [ 1056 | "$\\displaystyle 2 \\sqrt{2}$" 1057 | ], 1058 | "text/plain": [ 1059 | "2⋅√2" 1060 | ] 1061 | }, 1062 | "execution_count": 102, 1063 | "metadata": {}, 1064 | "output_type": "execute_result" 1065 | } 1066 | ], 1067 | "source": [ 1068 | "sqrt(8)" 1069 | ] 1070 | }, 1071 | { 1072 | "cell_type": "markdown", 1073 | "metadata": {}, 1074 | "source": [ 1075 | "That's beautiful! For even more beauty, here's $\\pi$ and then a numerical approximation with $40$ significant digits." 1076 | ] 1077 | }, 1078 | { 1079 | "cell_type": "code", 1080 | "execution_count": 103, 1081 | "metadata": {}, 1082 | "outputs": [ 1083 | { 1084 | "data": { 1085 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA8AAAAPCAYAAAA71pVKAAAAyUlEQVR4nKXSPWpCQRSG4cdgaRMhnaSyCBjwJtvIAuIW3ID1bbIGKyFtJIV9WheQP8EiW7AI2ASCWjjCMJkbjfngcIZz5uV881Mry9KxOonWN1gfGAXUI/gTQ/Qxw2PUu8AtpnjCawpPcRbgCeLzDAJ8j1HOtp0dPCf161y9Cn7JwN943wcv8RHVGmhjjq8q+BTntpexjupXqKWWU/g3yw6F002XIb8dM7kZcgetKriLVWbCGAvcoRc34k9SyOshxA+lT/Un/QveAOpeLi0OPTZyAAAAAElFTkSuQmCC\n", 1086 | "text/latex": [ 1087 | "$\\displaystyle \\pi$" 1088 | ], 1089 | "text/plain": [ 1090 | "π" 1091 | ] 1092 | }, 1093 | "execution_count": 103, 1094 | "metadata": {}, 1095 | "output_type": "execute_result" 1096 | } 1097 | ], 1098 | "source": [ 1099 | "pi" 1100 | ] 1101 | }, 1102 | { 1103 | "cell_type": "code", 1104 | "execution_count": 104, 1105 | "metadata": {}, 1106 | "outputs": [ 1107 | { 1108 | "data": { 1109 | "image/png": "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\n", 1110 | "text/latex": [ 1111 | "$\\displaystyle 3.141592653589793238462643383279502884197$" 1112 | ], 1113 | "text/plain": [ 1114 | "3.141592653589793238462643383279502884197" 1115 | ] 1116 | }, 1117 | "execution_count": 104, 1118 | "metadata": {}, 1119 | "output_type": "execute_result" 1120 | } 1121 | ], 1122 | "source": [ 1123 | "pi.evalf(40)" 1124 | ] 1125 | }, 1126 | { 1127 | "cell_type": "markdown", 1128 | "metadata": {}, 1129 | "source": [ 1130 | "Euler's number is just as spectacular." 1131 | ] 1132 | }, 1133 | { 1134 | "cell_type": "code", 1135 | "execution_count": 105, 1136 | "metadata": {}, 1137 | "outputs": [ 1138 | { 1139 | "data": { 1140 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAPCAYAAADUFP50AAAA6ElEQVR4nLXSvyvFURjH8df3Xsof4E7KZKG7GZQUkz+AO7DYKXUXiem7KOtdjMqk/BgMUjIZLDarzWKxWKhLMjjydPsepHyWT53neT9Pn3NOUZalv6iWOZ/HGR7QxS02Uc+BdezjCCM4xA7esIXdHNjBArYximW00cQVljDWC05gBSfYwGuovWAv9OkLxVUUeEJZkbuZvOgFZ5MvVkBRdxEcQAOXmP4BxFfGIvngb6AIPuPGx43NZXqnhHeMGddwimNcpEE1DGEc/RiuAs8xifU0fQaPuE+DDuL6CMI1Wt9l+1Tur/4f+A47hiS6Sx1iKwAAAABJRU5ErkJggg==\n", 1141 | "text/latex": [ 1142 | "$\\displaystyle e$" 1143 | ], 1144 | "text/plain": [ 1145 | "ℯ" 1146 | ] 1147 | }, 1148 | "execution_count": 105, 1149 | "metadata": {}, 1150 | "output_type": "execute_result" 1151 | } 1152 | ], 1153 | "source": [ 1154 | "exp(1)" 1155 | ] 1156 | }, 1157 | { 1158 | "cell_type": "code", 1159 | "execution_count": 106, 1160 | "metadata": {}, 1161 | "outputs": [ 1162 | { 1163 | "data": { 1164 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgAAAAASCAYAAAAt+WZDAAALVElEQVR4nO2de9AXVRnHPy9iaihSGTLdQEiDoFJTwryhIWlaXpKmGiksRUeLyBhtvEJNI1Y6pDWllYnmjBjdTNBQZES6MZORo1ig8JoXRPFCEIgp9sf37Lzn3Xcv5zy7v3Um9jvDnPe3e855zrPf53n27DnPLl0zZ86kRYsWLVq0aLFjoZ/391uAM4BfA48AW4GNwDLgi6m6eZgCvFby79WMdqcC1wD3Af929X4eIO94YBHwhBvvGuAXwCGpelV0C5VRRZcYGU3qksZkeng8I+N8N/m8P51Rvwv4AvBnYBOwBfgbMA3YqWAc7wCuB54Ctjm5c4A31aCDRQ8rJ1cAi4HHXZvnkf6XuT6rjssiw8fhwC+Bdeg6r0P287GMujGcNGXDU7DFIx9l9mKVYYkTnbaXqveAGHuJqV/HvQnCfD8mJk0hnntLm+6Cumkeo/rv7zWcBPwQkbAE+BewN3AK8BPgOFfnNfKxApiVc+5w4GjgjoxzFwMfADYjxx5ZICPBFcD5wHPAb4ANwLuBE4FPAp+jx6GsusXIsOoSK6NJXXy8EwWszcDuBfU2osCfxuaMY3ORUz4DzAP+A0wAvgcckaPHCOCPwGDgt8A/gLHAV4BjgUOdjlV0iNXDyslXgfuBu9A1GACMA2YCU93fj1cYl1UGyI6/iezkdqfbXsABwHhgoVc3lpOmbHgFtniUIMRerDIsMa/T9lLlHhBjL7H167g3hfp+TExaQTz3ljYQzmNU/13eFsDRyKAWANu9RkOA5egCnopmbBb8CRnoicBtqXNHISd4BDgSkXwzcFpOX0OAJ4Fngfcjsvy+7gHWAsPdMYtusTIsulhkNKlLgi4UdPYBfgXMAM5Ezuej25XDcvrxcRKa0a9FN4sN7vjOwK3u/OnADal2vwcmohn5Nd7xq1CAvBY4u4IOsXqA3Xd2BV7K6O9bwIUo6J1TYVwWGaAgdytwNwqym1Lndwb+6/2O5eT1sOE0iuIRxNmLRUZszIPO24vVjmPtJbZ+1XtTKJcnYYtJWSizr5g23a4cFthPcP/+0sk9wO/ofYFBSww/cn+PNwoe4wQ/iUhMYwmwmuIZnI+haOx/oXcgSPraBLzVO2bRLVaGfy5UF4uMJnVJMA054eloRlwHTnHllfQ4GsjxL3F/fznVZji60XQDP0idu8yNbTIKFml0QocEVt/JCuagYAOwb+WRxcvoh560twCfpW9wht7B2cLJ62HDPsriEVS3l7pjHnTeXiy8xNpLbH3ruHyEcmmJSVkIsa862sQgs//+udV7IyHkFaPws1z5U8r33EKwGngZzdL2ojdZRwB7oCXCEOTpVqeMPNQtoxO6jAJmoyWwpciRirALeop5F3K2B1y7NO9DXLkmo4/k2IHAIOBF9zuRvYi+wWAT8Ad0MxqH9kqtOsToUQaL73zclQ90cFx5Mj6MnpTmAy+gPfcx6OazHD1F+LBykocm/LEsHlnsJVZGnWjCXvJ4ibWX2PrWcSWI4dISk7Jg4b6sTVUeM/sPmQD0R3trAHcGCvOxGxr4duKWz4rwPHABWmJciRz/ObQX+Qm03HNWXmMPRbrVJaMIdcrohC79gZvQntuFgeMY4tr4WItm3/d6x5IAvk9GH/4y7kiUkAPwHleuypG9Gt1s9qPnZmPRAcL1KEKo78xA+5J7AgcBhyEHn13juEJlHOzK9Wi/+X2p80vRcuuz7reFkzw04Y9l8chqLzEyqqIJe/FRxEusvcTWt44rOR/DpSUmpWHhPqRNFR5z+w+ZAMxGM7SFaK8vFp9CM6YFZCcbWTEHLTtej/ZzEjyC9mjSy4RZKNOtDhllqEtGJ3S5FCXlHIYyb8vwM5TV/BB6+hsOfAklKN2BMrX/7ureDnwGOA+4BQV4kE36SSx+FvmertyYIz85PqiCDrF6FCHUd2agpKYEd6Js3nQQrDKuUBmDXXk2CjAT0LL7ULQ0+lGUdT/e1bNwkocm/LEsHlnsJVZGVTRhLz6KeIm1l9j61nFBPJeWmJSGhfuyNlV5zO2/7PWJacDXUFbv5JK6eZjqymuN7fNwPlpGugE9BQwAPoiWam4Gvl3SPkS3qjJCUIeMTugyFs2aryR8WW4W2q9bj/b4HkSOfhWahc706t6CjHcEeqK7DgX4Feg1oNWuXsxSZZcrk31Viw6xeuQhxneGoLEPQfuQw9GrRwfWOK5QGcmrTl3oSWwxyjR+CDgZJa4dSfiro2lO8tCUPxbFI6u9xMioA03YS4IyXmLtpS77KhuXhcs6YpKF+7I2VXnM7b9oAnAu2jdZiTJWny+om4f3oj2fJ+j7GkgVjEeJJLeh2doadGHuR0b0JDKOvIzgEN2qymhCj07pkiydraIn+aUKkkSdI7xj29HS7QyUzDMZvX/7BJqxJ6+N+U91ydPknmRjoFevbh0gW48sWH1nPcpCnojefb6x5nGFyHjBlWvo+1SxlZ4nrbGujOEkD035Y1E8qsteOhXzstBpewnhJdZeYutbxmXl0hKTfFi4r2IvITwW9p83AZgOfB/NNI4i/yMjZehUIswJrlyScW4LSibph5Z/0phOmG5VZISiqozpdEaX3dGe7SiUnON/ROIyV+fH7vecHJk+EodJZ+e/gmbo+6OZ7ED03vhKd2wrejJI8E9X7pcjJ8mCXtUBHYr08DGd6r7zGLoGo1HCWx3jCpWRXOMXc9olAXy3VP0QTrIwneb8sSge1WUvTSb/JeiEvUwnjBervYTWt4yrCpexMclHJ5L/ihDCY2H/WTkAF6C9lRXAMfTOto3BrmgGtd0JrxO7uDLvtZ/k+Mup4zG6WWXEoIqMTuqyjXzODkRBdhly5pDltWQ5Lyu7NguTkf3MpfcrQUnwn4iCvZ91vgf64MxWlKBTZHcWHaBcj7p8B+BtrgwJCrHXt0jGUhQE9wXeQF/bG+PKblfGcJJGk/5YFo/qsPlOxrwy1GkvMbzE2ktsfcu46o5fkB+TEli4r2ovZTyW9p9eAbgEXeC/Ah+hPICNQBmRO2ecm4SSJRZSfyLMfa6cCrw9de44FHReQl8nSxCrm0VGLKwyOq3LVvSpzKx/yQcq5rrf89zv0cCbM2QPRTN26PulwYH0xcFIt83AN1LnHkWvmw1Dy4A+ZqGZ8I3oNRmLDlY9IJ6TkfS8duSjH/qwy2DER/JEZBlXrAzcuOehJf1LU+2OQUlaG+nJuo7hxEfT/lgWj6z2EiOjCpqwF4jnJdZeYutbxlWFy9iYlMDCfUgbK49B/fsrAJ9Hyr2KnG1aRv1uen8FabEbyD70nbEliQfX5QzOx0nuH/QY+SGerA1oXybBfPQVqQnAw2gf7Gm05HMCSjD5Oj17NhbdYmVYdLHIaFKXGExyfSxB2b2b0ATxeDQTXQh8N9XmLuSsD7r6o1GyzTaU3JQ1sz0HBbqrUSB4GPgQWg5cBVxUQQerHhZOjgW+g56IHkXXfm+UADUc8eNnulvGFSsjwXnoml6E9heXIz8/2el4Jr2XcGM5eT1sOCYeWdHJmNeEvVh4gXh7ia1vHZcFlpgENvsKaWPhMbh/fwKQvPu4E9pnycK9hF3kUShpIjSxYX9Eso/h9CT0PEZvZ9iOSDkX+DQynDeiZJCFKBAt8upbdIuVYdHFIqNJXWKwBL0TfgAKZAOQEy9DCTk30TcTfL4bz2lov+0p9J7qbLKXAEHB7yAUEI51eq1zOszClqxaVQ8LJ3cjxzwUfRN+EHpKXuVkXE1vXSzjipWR4BkUoC9GtjIOBZ4FwOX0Xc6P5aRpG46NRxZ0OuY1YS/We0CsvcTWr/PeVAZLTLLYV2gbC4/B/Xe1/x1wixYtWrRoseOh7DsALVq0aNGiRYv/Q7QTgBYtWrRo0WIHxP8A8t3/0M30RTYAAAAASUVORK5CYII=\n", 1165 | "text/latex": [ 1166 | "$\\displaystyle 2.718281828459045235360287471352662497757$" 1167 | ], 1168 | "text/plain": [ 1169 | "2.718281828459045235360287471352662497757" 1170 | ] 1171 | }, 1172 | "execution_count": 106, 1173 | "metadata": {}, 1174 | "output_type": "execute_result" 1175 | } 1176 | ], 1177 | "source": [ 1178 | "exp(1).evalf(40) # Foury significant digits" 1179 | ] 1180 | }, 1181 | { 1182 | "cell_type": "markdown", 1183 | "metadata": {}, 1184 | "source": [ 1185 | "The trigonometric and logarithmic expressions from above will also now give us an exact solution." 1186 | ] 1187 | }, 1188 | { 1189 | "cell_type": "code", 1190 | "execution_count": 107, 1191 | "metadata": {}, 1192 | "outputs": [ 1193 | { 1194 | "data": { 1195 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAACAAAAAUCAYAAADskT9PAAABxklEQVR4nNXVTYhNYRgH8N81kyyUhQULC2ZFKTYWNj5LNPm4gyUW7JSIUqJuVnZiFAsLC1smyVfKxMhCKUpSpnykDA01IvIxY/E+V7fXve5p7in519v7nvP+z//5n/d5znMqtVrNv8SU7HoL+jGEj5jA+QI6s/ATJzETuzCAYXzBGO5iZx6zOxM6jEX4hNeYX/BFNobwALbiNN5gEK/CYB/OYl1wJpoZ2BeBh7E8BIqgive4gwo24ArGGziHcB+bw8wF/kzBIJ7V3RXEDKzCZSkNt2I9nvFGcCbWK+o3cwOTQS+m4mIB7veYf5RpoIrPuNmG143tsb5eloFpWItr+NqGewwLcRU3yjKwBtOl6v8b9mA/nmJb40anBqr4JlV8K+zGCTzBSnwoy0AX1ktVP9aCsxen8DiCj+SETgwsk7peq+M/iON4GMHfNSN1YqBP+tYvNdk7IhXdA6zGaCuRvBNuigGzY16Kc7EexYEG7j28zTR24KjUlIakAszxoq6ZG1gcAo3oiQEvw8ASzJGOOMe8mLukGmiG23UDeQpqUi9vNeYGrxpzs/y306gooRVX8QjPJ/n8b+QpKIoFnQauo4x/wf9t4BeS7lxe24+3EQAAAABJRU5ErkJggg==\n", 1196 | "text/latex": [ 1197 | "$\\displaystyle \\frac{1}{2}$" 1198 | ], 1199 | "text/plain": [ 1200 | "1/2" 1201 | ] 1202 | }, 1203 | "execution_count": 107, 1204 | "metadata": {}, 1205 | "output_type": "execute_result" 1206 | } 1207 | ], 1208 | "source": [ 1209 | "sin(pi / 6)" 1210 | ] 1211 | }, 1212 | { 1213 | "cell_type": "code", 1214 | "execution_count": 108, 1215 | "metadata": {}, 1216 | "outputs": [ 1217 | { 1218 | "data": { 1219 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA0AAAASCAYAAACAa1QyAAAAh0lEQVR4nO3RIQ7CYAwF4G8EPY0kCIIbllsg8NNIkknEfwcugOAeCE5CgkQR/GZ+1WTLMFM0eWlf05fXtEVKya8xC/yACx74oMUtiuaBn1Hhixc2Y5xOWKPEsW+96HTvGxxyGhV/0eSi+Nx9Bixy3uGa6zeaKNqiDr1VBjzRxPUSigEsmfIQHbJ7ECMDdcssAAAAAElFTkSuQmCC\n", 1220 | "text/latex": [ 1221 | "$\\displaystyle 1$" 1222 | ], 1223 | "text/plain": [ 1224 | "1" 1225 | ] 1226 | }, 1227 | "execution_count": 108, 1228 | "metadata": {}, 1229 | "output_type": "execute_result" 1230 | } 1231 | ], 1232 | "source": [ 1233 | "log(exp(1))" 1234 | ] 1235 | }, 1236 | { 1237 | "cell_type": "markdown", 1238 | "metadata": {}, 1239 | "source": [ 1240 | "## Substitutions" 1241 | ] 1242 | }, 1243 | { 1244 | "cell_type": "markdown", 1245 | "metadata": {}, 1246 | "source": [ 1247 | "While we create symbolic expressions, `sympy` does not exclude use from substituting actual numerical values into our mathematical variables. The `.subs()` method does the job. Below we create an expression and assign it to the computer variable `expr`." 1248 | ] 1249 | }, 1250 | { 1251 | "cell_type": "code", 1252 | "execution_count": 109, 1253 | "metadata": {}, 1254 | "outputs": [ 1255 | { 1256 | "data": { 1257 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAADMAAAASCAYAAAD2Uea5AAAByklEQVR4nN3WT4hOURgG8N83LC1maSMbGyt/FlajUCgbspHFZMSCjaQUMroLSqF82Sg0M002zNKGDU1iY8FCoZSkJEkKE4sZi/dMbtf9vnvNXKNvnjrd23nf+57nOX+ee1pZllks6PvfBP4Sg5hJ7WAx2EtiVuAKvnZKWAgxQ2ImN82jRgsj+ISrnZKKYu6lgXeXFBtNsfPzIDVXHMEW7Me3TklFMccxjbNYkuu/iH24hhON0qzGajGBbUx2SyyKeYbxVGAw9Z3CMdzCoUZpVmNp4vM28ahMLuI09iDDMpzDXSFuuimWNXEG6zCAqarkMgN4h8tYKdzjkThDP2sM/sZv65xtIyl2vyQ22qXWBrEal/C4xtilKwMfc+8H8L1OMTEJ/YW+tdiJMSE2j6ddeI3jFYZrjq1VcgPYi5v4gOXCCg/XLViCIbE6m/Gg5jf9+Fwzt42j/LkyO8QMPhdWOCn+tG28qFm8CfzAjQ6x9eIcPcRLuS2YFzOACXFmtomtNozbwhp3Nc24C6aUXFcSMiFmDNfzgVkDWIM7+IKteJ/6J/BE7PmNjdL9B+jDKmG9M9iO14Wck+l5YQF5zQllBtCz6KVbcyUWlZhfJHNe2+ms17gAAAAASUVORK5CYII=\n", 1258 | "text/latex": [ 1259 | "$\\displaystyle x + 4$" 1260 | ], 1261 | "text/plain": [ 1262 | "x + 4" 1263 | ] 1264 | }, 1265 | "execution_count": 109, 1266 | "metadata": {}, 1267 | "output_type": "execute_result" 1268 | } 1269 | ], 1270 | "source": [ 1271 | "expr = x + 4 # x is a mathematical symbol\n", 1272 | "expr" 1273 | ] 1274 | }, 1275 | { 1276 | "cell_type": "markdown", 1277 | "metadata": {}, 1278 | "source": [ 1279 | "We have to specify the mathematical variable we want substituted and then the value we want to substitute with." 1280 | ] 1281 | }, 1282 | { 1283 | "cell_type": "code", 1284 | "execution_count": 110, 1285 | "metadata": {}, 1286 | "outputs": [ 1287 | { 1288 | "data": { 1289 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA0AAAASCAYAAACAa1QyAAAAuUlEQVR4nJ3QwW3CQBSE4Q/EIblBGUQpAEVwoYfklEickjZMGSAoAyiBq28pwKSMEA6sJcvZtQ0jrd5qnv7V7PSyLHOr+pX7An8t5xcGFSjHMvH4DHMcYlCegI5hruvxUnrGBD/YdYW+wtwKf2qDHvGOMzal2Qa9YehaQNEV+gxzVTWboCe84IR9V+hfAW3QAz5cC9jWlynoFaMQq6gvU1BZwDq2jEFjTEUKKDWIeN/oJRI0xmvUXdAFKJclWUUCPlgAAAAASUVORK5CYII=\n", 1290 | "text/latex": [ 1291 | "$\\displaystyle 7$" 1292 | ], 1293 | "text/plain": [ 1294 | "7" 1295 | ] 1296 | }, 1297 | "execution_count": 110, 1298 | "metadata": {}, 1299 | "output_type": "execute_result" 1300 | } 1301 | ], 1302 | "source": [ 1303 | "expr.subs(x, 3)" 1304 | ] 1305 | }, 1306 | { 1307 | "cell_type": "markdown", 1308 | "metadata": {}, 1309 | "source": [ 1310 | "If we have more than one mathematical symbol, we can substitute all of them using the syntax below." 1311 | ] 1312 | }, 1313 | { 1314 | "cell_type": "code", 1315 | "execution_count": 111, 1316 | "metadata": {}, 1317 | "outputs": [ 1318 | { 1319 | "data": { 1320 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA0AAAASCAYAAACAa1QyAAAAuUlEQVR4nJ3QwW3CQBSE4Q/EIblBGUQpAEVwoYfklEickjZMGSAoAyiBq28pwKSMEA6sJcvZtQ0jrd5qnv7V7PSyLHOr+pX7An8t5xcGFSjHMvH4DHMcYlCegI5hruvxUnrGBD/YdYW+wtwKf2qDHvGOMzal2Qa9YehaQNEV+gxzVTWboCe84IR9V+hfAW3QAz5cC9jWlynoFaMQq6gvU1BZwDq2jEFjTEUKKDWIeN/oJRI0xmvUXdAFKJclWUUCPlgAAAAASUVORK5CYII=\n", 1321 | "text/latex": [ 1322 | "$\\displaystyle 7$" 1323 | ], 1324 | "text/plain": [ 1325 | "7" 1326 | ] 1327 | }, 1328 | "execution_count": 111, 1329 | "metadata": {}, 1330 | "output_type": "execute_result" 1331 | } 1332 | ], 1333 | "source": [ 1334 | "expr = x + y # Overwriting the expr computer variable\n", 1335 | "expr.subs([(x, 2), (y, 5)])" 1336 | ] 1337 | }, 1338 | { 1339 | "cell_type": "markdown", 1340 | "metadata": {}, 1341 | "source": [ 1342 | "The square bracket, `[]` notation creates a list object. An alternative syntax uses dictionary objects with curly braces, `{}`. We will learn more about these at a later stage." 1343 | ] 1344 | }, 1345 | { 1346 | "cell_type": "code", 1347 | "execution_count": 112, 1348 | "metadata": {}, 1349 | "outputs": [ 1350 | { 1351 | "data": { 1352 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAACEAAAASCAYAAADVCrdsAAABr0lEQVR4nM3VTUsWURjG8Z+RkElqG1dBvpBWtIzetIUK0heoVUJtKgoKadmix0XbCMWgUJG+gQsVAmmVtXRnKUJgtWshEdEibXHO4PjwzDMzQtQFw3U49+E+/zlzn3saKpWKf60DqfEN7OQ8v0vmP4YZfMUvfMIzHE0vOpgar2AsI9llDGKxBEA3ltGOOXzAOTzAFfThWy2IlYyE76K/LAHxPALcx0Rq/ilG8QR32Ps5snQGF/AF8wUBujAsHP9kVewxfmAEzUUhbkefVrwmBqO/xnZV7Dve4rDwcrkQTbgeE00VBIDe6GsZ8fXoPUUgrqFNKMjNEhCt0bcy4sl8WxGIW9FflAAoooboO3kQp3EJn7FQcpPkTVsz4i3pdfUg9lOQiT5G78mIn4i+Vg/ikHCFtiNEWb2JPlxjjyNCo/qJ9/UgrgqtdUH9guzGSTRWzW8I17MD96piY0J/eCX0iz0dM62kIPM65BKOo1NoTGndFdr2OIawivMYED7Do2RhrZM4hX77K8i0NnAWs3Hzh8LJjeOi+N+g9kms2r1CeerIiW/iZl6SIm37r+u/gPgDbL1WG7Qav3wAAAAASUVORK5CYII=\n", 1353 | "text/latex": [ 1354 | "$\\displaystyle 7.0$" 1355 | ], 1356 | "text/plain": [ 1357 | "7.00000000000000" 1358 | ] 1359 | }, 1360 | "execution_count": 112, 1361 | "metadata": {}, 1362 | "output_type": "execute_result" 1363 | } 1364 | ], 1365 | "source": [ 1366 | "expr.evalf(subs = {x:2, y:5})" 1367 | ] 1368 | }, 1369 | { 1370 | "cell_type": "markdown", 1371 | "metadata": {}, 1372 | "source": [ 1373 | "## Equality" 1374 | ] 1375 | }, 1376 | { 1377 | "cell_type": "markdown", 1378 | "metadata": {}, 1379 | "source": [ 1380 | "Substitution provides a great segway into Boolean logic. The double equal symbol, `==` evaluates both sides of an equation to see of they are indeed equal." 1381 | ] 1382 | }, 1383 | { 1384 | "cell_type": "code", 1385 | "execution_count": 113, 1386 | "metadata": {}, 1387 | "outputs": [ 1388 | { 1389 | "data": { 1390 | "text/plain": [ 1391 | "False" 1392 | ] 1393 | }, 1394 | "execution_count": 113, 1395 | "metadata": {}, 1396 | "output_type": "execute_result" 1397 | } 1398 | ], 1399 | "source": [ 1400 | "expr.subs(x, 3) == 7" 1401 | ] 1402 | }, 1403 | { 1404 | "cell_type": "markdown", 1405 | "metadata": {}, 1406 | "source": [ 1407 | "Indeed $7 = 7$, the LHS equals the RHS." 1408 | ] 1409 | }, 1410 | { 1411 | "cell_type": "markdown", 1412 | "metadata": {}, 1413 | "source": [ 1414 | "The `sympy` adheres to the principle of exact structural equality. Let's look at the expression $\\left( x+1 \\right)^2$ and its expansion $x^2 + 2x +1$." 1415 | ] 1416 | }, 1417 | { 1418 | "cell_type": "code", 1419 | "execution_count": 114, 1420 | "metadata": {}, 1421 | "outputs": [ 1422 | { 1423 | "data": { 1424 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEsAAAAYCAYAAACyVACzAAADT0lEQVR4nO3YW4hWVRQH8N+oD4ndLRoITCKyIGqiCLuJlRfopejyIJRJBiZEYRSoGHxEF6EkKzKoh6bLQ4VCkS+WoSiFeIHppkFFdhFLxSiwRMrpYZ2Tp+35Zs53xvk+kfnDZs+svdbe6/ufddnndDUaDSOohlGdduA4wiJswR/Yiw9wSVFhhKwjmIoVuAY34m+sxZm5QjOy3sAejBte/9qKK9CPuU3WZ+I1fIkvcDfOxrW5QhlZV+IuLMWBY+jscOAOvIiNIn368VYT3W14D0/g5Ap7nyL42Z8Lysh6Kjv45aoedxBL8AB6sKuC/tPoxoMVdJejD5tyQUrWhZiGd/FXhQ2HijkiGqbWtF8gfD4V8yvob8bXmIfRA+g9gym4E//kwpSse9GFd0o2+FD8sNsSeRd6s7WlFRw+lliHb7Kzq+JtTBBBUYZlmI2b8G1xISVrmmByk6PxKA6LnC8+lWdxD17Fwhac7hQ+yebpJWsviHp9A7ani0Wyxonc36G8sH+GN3Gx6BSwGA+LtL2/db87gi3ZPCWRrxBlYZYo6t3Z+K8ZFMk6V0TM7gEOWoKDaIjC+iTWCPIO13S+3fhd/IYJiXy+6IAfCw7y8UiuMKagPD6bfxvgoJ9Fl1goWvanooYdquDkTpzXZG1diex18aSHA/txTiLrGsyoSFbe/U4axGZv4e+5+HNQ1wLLcXoi68EtgpidyVpfxX3rYKwa3b5I1p5sHl+mmGGWKOi/iHx+SLWWTZCVYo4gqxfrK+4zVIwSD+37OoY5douomdRE92YRAV/hUnFfuQ8XtXpohzFJpFxfq4ZFsvqxAWfhgkTvOqwUNWuGIPUxEZntvlsNFZOzuaxODogxyf+rcLt4qcwvZJdhtegi0x3pliuxVaTR9eL9rN24NRtEWYCrRVrDPoVulmGGuEu+3+phZWT9Km6wL4kIWyOibia+S/QX4SPxejBZ+9EjLsRFnJ8N+MH/yTpNkLsaP7V6WHqDP4TncRUuF9HVjTPweYn9WpH/dYnqzezX17RvZPbNxsREf7bo9svqHFb21eE5/IjH62x4HGOsyIRVapaMMrIOihv5VifWx7+JeMXRNawy0pqVY0M2TiTsEGlbGyPf4FvACFkt4F9jSKJg0sBn9QAAAABJRU5ErkJggg==\n", 1425 | "text/latex": [ 1426 | "$\\displaystyle \\left(x + 1\\right)^{2}$" 1427 | ], 1428 | "text/plain": [ 1429 | " 2\n", 1430 | "(x + 1) " 1431 | ] 1432 | }, 1433 | "execution_count": 114, 1434 | "metadata": {}, 1435 | "output_type": "execute_result" 1436 | } 1437 | ], 1438 | "source": [ 1439 | "(x + 1)**2" 1440 | ] 1441 | }, 1442 | { 1443 | "cell_type": "code", 1444 | "execution_count": 115, 1445 | "metadata": {}, 1446 | "outputs": [ 1447 | { 1448 | "data": { 1449 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAG4AAAAWCAYAAAAhKqlXAAADG0lEQVR4nO3ZX4hUZRjH8c/mXppEXuRFEIpEQaiX2j82RaUuKtQuJNMlvUiKNC3SUBikQLBoK7AgoZW6iqCLIso/bWGIUMEGFZEFqwlJSmCIianrxXPS4eXsjHPOnGUG5gsvc+b9d97fed73eZ/znr5araZH93FDyfZb8S3+wSl8grvKDqpHc8oabgC7cTcW4iIO4OaS/fZoQn/J9kuT/0/gDO4Rq69HRZRdcSk3Zn3+3eZ+mzEd6/AxfsO/YgJ9g7Xar7MqVuAtHBLbzzg+yKtYdsWlDGEUR9rcbzMew9v4EyM4jluwDHvwYFZnfJLH1SrbMBdncQJ3TFSxnTNxF+4XD+hSgfaD4sEOFGj7Kx7GrXhcBE1PCuF/YLkwYtUMKq4BnsPtmIb1jSqmhtuX3TgV2YfhrGxnTj+vYTUWCVc12Xwp9tTLSf5JvJNdDyRlRbVWyQiOug7PkBruBSH+ZUypy38Va/AutiRt3sQqPICfi423Uv7Lfi8m+UW0dgyp4X7A+7hTRIjwEjbhQzyV1N8t3MNKEZDMyNLUaobbMv3CE8DnSVmrWjuKvD1uG86jhmfwCr4Q4lJXtF5EkgdFYPB/er6a4bbMTnEg8JnQkNKK1o4iz3AnRHR4mwhND4t94EJO3b4JUq3JfceEH69P72VlIzllw9cjJuFZbMYvrq2olFa0pozljLPdGiZkoteBU3XXa3GunTcVD+umJG8eHsFe8VDqGW2x/6fxhthzF2n8XllU65BqNTQkz3ArxQZ9UuxXGzQJTQswlJM3KEQP46sSfW/E6/hRGO2vBnXLaB3KyRvUHg1NSV3lQ2K2/IQ5ws2s0+BFsMN4URhtVES5jYzW1VrrDXcvPhJ+f4lwIdvFqpzs95kibBfj/F6stNMN6na71quuci4+Fed7i0VkSIj7Tiz/+8QZWieyBjvEic0hEZikjAkX1slaH80S4bphgWuBzWlZxN6P2SIEHhen/b8nnW3FfnGkNb+a8ZZmZvY7RexxeXwtDp07Wes8MQnrmZUlOCYzXF/vC3h30i2fO3ok9AzXpfQM16VcAVyY2F1U6yvkAAAAAElFTkSuQmCC\n", 1450 | "text/latex": [ 1451 | "$\\displaystyle x^{2} + 2 x + 1$" 1452 | ], 1453 | "text/plain": [ 1454 | " 2 \n", 1455 | "x + 2⋅x + 1" 1456 | ] 1457 | }, 1458 | "execution_count": 115, 1459 | "metadata": {}, 1460 | "output_type": "execute_result" 1461 | } 1462 | ], 1463 | "source": [ 1464 | "((x + 1)**2).expand()" 1465 | ] 1466 | }, 1467 | { 1468 | "cell_type": "markdown", 1469 | "metadata": {}, 1470 | "source": [ 1471 | "We know that these two expression are equal to each other. Let's test this assumption." 1472 | ] 1473 | }, 1474 | { 1475 | "cell_type": "code", 1476 | "execution_count": 116, 1477 | "metadata": {}, 1478 | "outputs": [ 1479 | { 1480 | "data": { 1481 | "text/plain": [ 1482 | "False" 1483 | ] 1484 | }, 1485 | "execution_count": 116, 1486 | "metadata": {}, 1487 | "output_type": "execute_result" 1488 | } 1489 | ], 1490 | "source": [ 1491 | "(x + 1)**2 == x**2 + 2 * x + 1" 1492 | ] 1493 | }, 1494 | { 1495 | "cell_type": "markdown", 1496 | "metadata": {}, 1497 | "source": [ 1498 | "We see a `False`. This is what we mean by adherence to the principle of exact structural equality. If we expand the LHS or factor the RHS, we will get equality." 1499 | ] 1500 | }, 1501 | { 1502 | "cell_type": "code", 1503 | "execution_count": 117, 1504 | "metadata": {}, 1505 | "outputs": [ 1506 | { 1507 | "data": { 1508 | "text/plain": [ 1509 | "True" 1510 | ] 1511 | }, 1512 | "execution_count": 117, 1513 | "metadata": {}, 1514 | "output_type": "execute_result" 1515 | } 1516 | ], 1517 | "source": [ 1518 | "((x + 1)**2).expand() == x**2 + 2 * x + 1" 1519 | ] 1520 | }, 1521 | { 1522 | "cell_type": "code", 1523 | "execution_count": 118, 1524 | "metadata": {}, 1525 | "outputs": [ 1526 | { 1527 | "data": { 1528 | "text/plain": [ 1529 | "True" 1530 | ] 1531 | }, 1532 | "execution_count": 118, 1533 | "metadata": {}, 1534 | "output_type": "execute_result" 1535 | } 1536 | ], 1537 | "source": [ 1538 | "((x + 1)**2) == (x**2 + 2 * x + 1).factor()" 1539 | ] 1540 | }, 1541 | { 1542 | "cell_type": "markdown", 1543 | "metadata": {}, 1544 | "source": [ 1545 | "## Roundtripping to numerical packages" 1546 | ] 1547 | }, 1548 | { 1549 | "cell_type": "markdown", 1550 | "metadata": {}, 1551 | "source": [ 1552 | "While `sympy` is great at symbolic computations, we often need numerical evaluations. We did this using `.subs()` and `.evalf()` methods. They do single substitutions, but what if want computations on many values. To do this, we rondtrip to some of the Python packages that are designed for numerical computations such as `numpy` (numerical Python) and `scipy` (scientific Python)." 1553 | ] 1554 | }, 1555 | { 1556 | "cell_type": "markdown", 1557 | "metadata": {}, 1558 | "source": [ 1559 | "Fortunately, `sympy` provides the `lambdify()` function. Imagine then that we want to calculate the $\\sin \\left( x \\right)$ for the integere values in the closed domain $\\left[ -3, 3 \\right]$. The `arange()` function in the `numpy` package will let us create this list of values. We will ause three argument. The first is the start value, the second is the end value (`numpy` excludes this from the final list, so we will use `4`), and the step size, which is $1$." 1560 | ] 1561 | }, 1562 | { 1563 | "cell_type": "code", 1564 | "execution_count": 119, 1565 | "metadata": {}, 1566 | "outputs": [], 1567 | "source": [ 1568 | "from numpy import arange" 1569 | ] 1570 | }, 1571 | { 1572 | "cell_type": "code", 1573 | "execution_count": 120, 1574 | "metadata": {}, 1575 | "outputs": [ 1576 | { 1577 | "data": { 1578 | "text/plain": [ 1579 | "array([-3, -2, -1, 0, 1, 2, 3])" 1580 | ] 1581 | }, 1582 | "execution_count": 120, 1583 | "metadata": {}, 1584 | "output_type": "execute_result" 1585 | } 1586 | ], 1587 | "source": [ 1588 | "my_domain = arange(-3, 4, 1) # Creating the list of integers in our chosen domain\n", 1589 | "my_domain" 1590 | ] 1591 | }, 1592 | { 1593 | "cell_type": "markdown", 1594 | "metadata": {}, 1595 | "source": [ 1596 | "The `arange()` function creates a `numpy` object called an `array`. We note the seven integers in our array object, `my_domain`. Now we overwrite the `expr` computer variable to hold the sine function." 1597 | ] 1598 | }, 1599 | { 1600 | "cell_type": "code", 1601 | "execution_count": 121, 1602 | "metadata": {}, 1603 | "outputs": [ 1604 | { 1605 | "data": { 1606 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAADwAAAAVCAYAAAAaX42MAAADSUlEQVR4nOXYW4hVZRQH8N+oQZOClRVCYOdBsiKyi4UPGQZqklJRDxF4wayMHgqiyKJgitJAzaKHQglMKaZwKEkiRYnsShnZQ9hDgZlmFykLKpus6WHt3XzuOWfv4zlHGugPh31mfd9ae12+9V/fma6enh7/J4xoQaeGAazrqCeDWI/vMboNG5cIHxcXF1oJ+HhiCubhcfzahp2P8SoexZh0oZWA9+Nc3N+GQ42wDL/gmQ7YWo7xuDMVthLwn/gcBzrgVIqzMQMv4/cO2PtQ+LkEI3NhMeBrsF0E8we+wVu4I9lTM7SHU1kNvTiIw9iJuU04eDO68FKD9a3ZO64vyLuy9w6IVkjRiwkikTg64NuwCefhNazC6+jGoiYchrNEZmvYkDl/fmb3ygrdGfgLHzRYvxd/i74cmchXYiHWYmlB593sOTMXjEoWl6AfkwVLpjitwtkc09GDhxPZi3gjc/jNBnqjcSF2a0xWn4okLsR8UdUHcLdog9vr6HyUPa/IBaMKG46IHi3iYAMnivhKVCDFFuzFZSV6Z4qqVfHCg7hRJHUMHsvszxfVL+Jn0VYTckF6pF/ASfgMq3EdTq9woIhd4lgW8TVOKdEblz1/qrC/D0+K1nka74me7i/R+VFyQtOAnxDHZa+g8lfwnTiGUyocyXGogfyI8omQs/KJTbzjh+T7YvxWsb87sT/EifWYKjI+B8+J878FZzThTKvIOWNc6S5uEiT1bfb3XRX7R+DkxH7DrB8SDH2rIIdTMa3CeDs4ICo3qWTP1XhetNwFYsbegnNKdCaJsbUrF6QBzzaUxBisbNXRaQcD2CF6bWKd9cuxUfTwLJGch4S/xdmbYmr2/Hc6pAH2CkZ7B3tEZqbhUnE33XbMYRwb+nADrsIXiXwyNgvGnWmQyTeKS821mZ9v17E5S5DoplyQVngp3sfF4ma1CCfgPnFpqDeuOok+QZILEtlEwR8DIhFfFnTy+/yKOvbGikmzWUwJHF3hZ7NPFfaI6lfJUkxvwm4/nhI/IC7CJ6LS40t0tpW8d4Fg/VWpcLj9PFwtxuIjbdrpFtXvUzjqwy3gw+LWtFN7/wCoYQ3uKS7UY+X/GjuyTzvYLa6fQzDcKnzc8Q8hv69AhWQtAgAAAABJRU5ErkJggg==\n", 1607 | "text/latex": [ 1608 | "$\\displaystyle \\sin{\\left(x \\right)}$" 1609 | ], 1610 | "text/plain": [ 1611 | "sin(x)" 1612 | ] 1613 | }, 1614 | "execution_count": 121, 1615 | "metadata": {}, 1616 | "output_type": "execute_result" 1617 | } 1618 | ], 1619 | "source": [ 1620 | "expr = sin(x)\n", 1621 | "expr" 1622 | ] 1623 | }, 1624 | { 1625 | "cell_type": "code", 1626 | "execution_count": 122, 1627 | "metadata": {}, 1628 | "outputs": [], 1629 | "source": [ 1630 | "from sympy import lambdify # Importing the required function" 1631 | ] 1632 | }, 1633 | { 1634 | "cell_type": "markdown", 1635 | "metadata": {}, 1636 | "source": [ 1637 | "The `lambdify()` function as used below takes three arguments. First is the mathematical variable of interest. Then follows teh actual expression, and finally the package we want to use for the calculation. We assign this to the computer variable `f`." 1638 | ] 1639 | }, 1640 | { 1641 | "cell_type": "code", 1642 | "execution_count": 123, 1643 | "metadata": {}, 1644 | "outputs": [], 1645 | "source": [ 1646 | "f = lambdify(x, expr, 'numpy')" 1647 | ] 1648 | }, 1649 | { 1650 | "cell_type": "markdown", 1651 | "metadata": {}, 1652 | "source": [ 1653 | "It is now a simple matter of providing the seven numbered array to the computer variable. All seven values in the array will be passed to the expression." 1654 | ] 1655 | }, 1656 | { 1657 | "cell_type": "code", 1658 | "execution_count": 124, 1659 | "metadata": {}, 1660 | "outputs": [ 1661 | { 1662 | "data": { 1663 | "text/plain": [ 1664 | "array([-0.14112001, -0.90929743, -0.84147098, 0. , 0.84147098,\n", 1665 | " 0.90929743, 0.14112001])" 1666 | ] 1667 | }, 1668 | "execution_count": 124, 1669 | "metadata": {}, 1670 | "output_type": "execute_result" 1671 | } 1672 | ], 1673 | "source": [ 1674 | "f(my_domain)" 1675 | ] 1676 | }, 1677 | { 1678 | "cell_type": "code", 1679 | "execution_count": null, 1680 | "metadata": {}, 1681 | "outputs": [], 1682 | "source": [] 1683 | } 1684 | ], 1685 | "metadata": { 1686 | "kernelspec": { 1687 | "display_name": "Python 3 (ipykernel)", 1688 | "language": "python", 1689 | "name": "python3" 1690 | }, 1691 | "language_info": { 1692 | "codemirror_mode": { 1693 | "name": "ipython", 1694 | "version": 3 1695 | }, 1696 | "file_extension": ".py", 1697 | "mimetype": "text/x-python", 1698 | "name": "python", 1699 | "nbconvert_exporter": "python", 1700 | "pygments_lexer": "ipython3", 1701 | "version": "3.9.7" 1702 | } 1703 | }, 1704 | "nbformat": 4, 1705 | "nbformat_minor": 2 1706 | } 1707 | --------------------------------------------------------------------------------