├── NumPy-Ejercicios-Serie3.ipynb ├── NumPy-Ejercicios-Serie4.ipynb ├── NumPy-Ejercicios-Serie5.ipynb ├── NumPy-Ejercicios-Serie6.ipynb ├── Numpy-Ejercicios-Serie1.ipynb ├── Numpy-Ejercicios-Serie2.ipynb ├── README.md ├── ejercicio35.npy ├── ejercicio36.npz └── ejercicio37.txt /NumPy-Ejercicios-Serie3.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Ejercicio 62\n", 8 | "\n", 9 | "Mostrar todas las fechas del mes de febrero de 2019." 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "## Solución:" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 1, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "import numpy as np" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 2, 31 | "metadata": {}, 32 | "outputs": [ 33 | { 34 | "data": { 35 | "text/plain": [ 36 | "array(['2019-02-01', '2019-02-02', '2019-02-03', '2019-02-04',\n", 37 | " '2019-02-05', '2019-02-06', '2019-02-07', '2019-02-08',\n", 38 | " '2019-02-09', '2019-02-10', '2019-02-11', '2019-02-12',\n", 39 | " '2019-02-13', '2019-02-14', '2019-02-15', '2019-02-16',\n", 40 | " '2019-02-17', '2019-02-18', '2019-02-19', '2019-02-20',\n", 41 | " '2019-02-21', '2019-02-22', '2019-02-23', '2019-02-24',\n", 42 | " '2019-02-25', '2019-02-26', '2019-02-27', '2019-02-28'],\n", 43 | " dtype='datetime64[D]')" 44 | ] 45 | }, 46 | "execution_count": 2, 47 | "metadata": {}, 48 | "output_type": "execute_result" 49 | } 50 | ], 51 | "source": [ 52 | "np.arange('2019-02', '2019-03', dtype='datetime64[D]')" 53 | ] 54 | }, 55 | { 56 | "cell_type": "markdown", 57 | "metadata": {}, 58 | "source": [ 59 | "# Ejercicio 63\n", 60 | "\n", 61 | "Obtener la fecha de ayer, hoy, y mañana." 62 | ] 63 | }, 64 | { 65 | "cell_type": "markdown", 66 | "metadata": {}, 67 | "source": [ 68 | "## Solución:" 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": 3, 74 | "metadata": {}, 75 | "outputs": [], 76 | "source": [ 77 | "import numpy as np" 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": 4, 83 | "metadata": {}, 84 | "outputs": [ 85 | { 86 | "data": { 87 | "text/plain": [ 88 | "numpy.datetime64('2019-02-12')" 89 | ] 90 | }, 91 | "execution_count": 4, 92 | "metadata": {}, 93 | "output_type": "execute_result" 94 | } 95 | ], 96 | "source": [ 97 | "ayer = np.datetime64('today', 'D') - np.timedelta64(1, 'D')\n", 98 | "ayer" 99 | ] 100 | }, 101 | { 102 | "cell_type": "code", 103 | "execution_count": 5, 104 | "metadata": {}, 105 | "outputs": [ 106 | { 107 | "data": { 108 | "text/plain": [ 109 | "numpy.datetime64('2019-02-13')" 110 | ] 111 | }, 112 | "execution_count": 5, 113 | "metadata": {}, 114 | "output_type": "execute_result" 115 | } 116 | ], 117 | "source": [ 118 | "hoy = np.datetime64('today', 'D')\n", 119 | "hoy" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": 6, 125 | "metadata": {}, 126 | "outputs": [ 127 | { 128 | "data": { 129 | "text/plain": [ 130 | "numpy.datetime64('2019-02-14')" 131 | ] 132 | }, 133 | "execution_count": 6, 134 | "metadata": {}, 135 | "output_type": "execute_result" 136 | } 137 | ], 138 | "source": [ 139 | "maghniana = np.datetime64('today', 'D') + np.timedelta64(1, 'D')\n", 140 | "maghniana" 141 | ] 142 | }, 143 | { 144 | "cell_type": "markdown", 145 | "metadata": {}, 146 | "source": [ 147 | "# Ejercicio 64\n", 148 | "\n", 149 | "Contar el número de días de febrero y marzo de 2019." 150 | ] 151 | }, 152 | { 153 | "cell_type": "markdown", 154 | "metadata": {}, 155 | "source": [ 156 | "## Solución:" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": 7, 162 | "metadata": {}, 163 | "outputs": [], 164 | "source": [ 165 | "import numpy as np" 166 | ] 167 | }, 168 | { 169 | "cell_type": "code", 170 | "execution_count": 8, 171 | "metadata": {}, 172 | "outputs": [ 173 | { 174 | "data": { 175 | "text/plain": [ 176 | "numpy.timedelta64(28,'D')" 177 | ] 178 | }, 179 | "execution_count": 8, 180 | "metadata": {}, 181 | "output_type": "execute_result" 182 | } 183 | ], 184 | "source": [ 185 | "np.datetime64('2019-03-01') - np.datetime64('2019-02-01')" 186 | ] 187 | }, 188 | { 189 | "cell_type": "code", 190 | "execution_count": 9, 191 | "metadata": {}, 192 | "outputs": [ 193 | { 194 | "data": { 195 | "text/plain": [ 196 | "numpy.timedelta64(31,'D')" 197 | ] 198 | }, 199 | "execution_count": 9, 200 | "metadata": {}, 201 | "output_type": "execute_result" 202 | } 203 | ], 204 | "source": [ 205 | "np.datetime64('2019-04-01') - np.datetime64('2019-03-01')" 206 | ] 207 | }, 208 | { 209 | "cell_type": "markdown", 210 | "metadata": {}, 211 | "source": [ 212 | "# Ejercicio 65\n", 213 | "\n", 214 | "Crear el rango de 24 horas para un día arbitrario." 215 | ] 216 | }, 217 | { 218 | "cell_type": "markdown", 219 | "metadata": {}, 220 | "source": [ 221 | "## Solución:" 222 | ] 223 | }, 224 | { 225 | "cell_type": "code", 226 | "execution_count": 10, 227 | "metadata": {}, 228 | "outputs": [], 229 | "source": [ 230 | "import numpy as np\n", 231 | "import datetime" 232 | ] 233 | }, 234 | { 235 | "cell_type": "code", 236 | "execution_count": 11, 237 | "metadata": {}, 238 | "outputs": [], 239 | "source": [ 240 | "fecha = datetime.datetime(2019, 2, 11)" 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": 12, 246 | "metadata": {}, 247 | "outputs": [ 248 | { 249 | "data": { 250 | "text/plain": [ 251 | "array([datetime.datetime(2019, 2, 11, 0, 0),\n", 252 | " datetime.datetime(2019, 2, 11, 1, 0),\n", 253 | " datetime.datetime(2019, 2, 11, 2, 0),\n", 254 | " datetime.datetime(2019, 2, 11, 3, 0),\n", 255 | " datetime.datetime(2019, 2, 11, 4, 0),\n", 256 | " datetime.datetime(2019, 2, 11, 5, 0),\n", 257 | " datetime.datetime(2019, 2, 11, 6, 0),\n", 258 | " datetime.datetime(2019, 2, 11, 7, 0),\n", 259 | " datetime.datetime(2019, 2, 11, 8, 0),\n", 260 | " datetime.datetime(2019, 2, 11, 9, 0),\n", 261 | " datetime.datetime(2019, 2, 11, 10, 0),\n", 262 | " datetime.datetime(2019, 2, 11, 11, 0),\n", 263 | " datetime.datetime(2019, 2, 11, 12, 0),\n", 264 | " datetime.datetime(2019, 2, 11, 13, 0),\n", 265 | " datetime.datetime(2019, 2, 11, 14, 0),\n", 266 | " datetime.datetime(2019, 2, 11, 15, 0),\n", 267 | " datetime.datetime(2019, 2, 11, 16, 0),\n", 268 | " datetime.datetime(2019, 2, 11, 17, 0),\n", 269 | " datetime.datetime(2019, 2, 11, 18, 0),\n", 270 | " datetime.datetime(2019, 2, 11, 19, 0),\n", 271 | " datetime.datetime(2019, 2, 11, 20, 0),\n", 272 | " datetime.datetime(2019, 2, 11, 21, 0),\n", 273 | " datetime.datetime(2019, 2, 11, 22, 0),\n", 274 | " datetime.datetime(2019, 2, 11, 23, 0)], dtype=object)" 275 | ] 276 | }, 277 | "execution_count": 12, 278 | "metadata": {}, 279 | "output_type": "execute_result" 280 | } 281 | ], 282 | "source": [ 283 | "horas_fecha = np.array([fecha + datetime.timedelta(hours=i) for i in range(24)])\n", 284 | "\n", 285 | "horas_fecha" 286 | ] 287 | }, 288 | { 289 | "cell_type": "markdown", 290 | "metadata": {}, 291 | "source": [ 292 | "# Ejercicio 66\n", 293 | "\n", 294 | "Encontrar la fecha del primer martes del mes de mayo de 2019." 295 | ] 296 | }, 297 | { 298 | "cell_type": "markdown", 299 | "metadata": {}, 300 | "source": [ 301 | "## Solución:" 302 | ] 303 | }, 304 | { 305 | "cell_type": "code", 306 | "execution_count": 13, 307 | "metadata": {}, 308 | "outputs": [], 309 | "source": [ 310 | "import numpy as np" 311 | ] 312 | }, 313 | { 314 | "cell_type": "code", 315 | "execution_count": 14, 316 | "metadata": {}, 317 | "outputs": [ 318 | { 319 | "data": { 320 | "text/plain": [ 321 | "numpy.datetime64('2019-05-07')" 322 | ] 323 | }, 324 | "execution_count": 14, 325 | "metadata": {}, 326 | "output_type": "execute_result" 327 | } 328 | ], 329 | "source": [ 330 | "np.busday_offset('2019-05', 0, roll='forward', weekmask='Tue')" 331 | ] 332 | }, 333 | { 334 | "cell_type": "markdown", 335 | "metadata": {}, 336 | "source": [ 337 | "# Ejercicio 67\n", 338 | "\n", 339 | "Encontrar la cantidad de días laborales para un mes arbitrario." 340 | ] 341 | }, 342 | { 343 | "cell_type": "markdown", 344 | "metadata": {}, 345 | "source": [ 346 | "## Solución:" 347 | ] 348 | }, 349 | { 350 | "cell_type": "code", 351 | "execution_count": 15, 352 | "metadata": {}, 353 | "outputs": [], 354 | "source": [ 355 | "import numpy as np" 356 | ] 357 | }, 358 | { 359 | "cell_type": "code", 360 | "execution_count": 16, 361 | "metadata": {}, 362 | "outputs": [ 363 | { 364 | "data": { 365 | "text/plain": [ 366 | "23" 367 | ] 368 | }, 369 | "execution_count": 16, 370 | "metadata": {}, 371 | "output_type": "execute_result" 372 | } 373 | ], 374 | "source": [ 375 | "np.busday_count('2019-05', '2019-06')" 376 | ] 377 | }, 378 | { 379 | "cell_type": "markdown", 380 | "metadata": {}, 381 | "source": [ 382 | "# Ejercicio 68\n", 383 | "\n", 384 | "Determinar si una fecha corresponde con un día laboral." 385 | ] 386 | }, 387 | { 388 | "cell_type": "markdown", 389 | "metadata": {}, 390 | "source": [ 391 | "## Solución:" 392 | ] 393 | }, 394 | { 395 | "cell_type": "code", 396 | "execution_count": 17, 397 | "metadata": {}, 398 | "outputs": [], 399 | "source": [ 400 | "import numpy as np" 401 | ] 402 | }, 403 | { 404 | "cell_type": "code", 405 | "execution_count": 18, 406 | "metadata": {}, 407 | "outputs": [ 408 | { 409 | "data": { 410 | "text/plain": [ 411 | "True" 412 | ] 413 | }, 414 | "execution_count": 18, 415 | "metadata": {}, 416 | "output_type": "execute_result" 417 | } 418 | ], 419 | "source": [ 420 | "np.is_busday(np.datetime64('2019-02-11'))" 421 | ] 422 | }, 423 | { 424 | "cell_type": "code", 425 | "execution_count": 19, 426 | "metadata": {}, 427 | "outputs": [ 428 | { 429 | "data": { 430 | "text/plain": [ 431 | "False" 432 | ] 433 | }, 434 | "execution_count": 19, 435 | "metadata": {}, 436 | "output_type": "execute_result" 437 | } 438 | ], 439 | "source": [ 440 | "np.is_busday(np.datetime64('2019-02-09'))" 441 | ] 442 | }, 443 | { 444 | "cell_type": "markdown", 445 | "metadata": {}, 446 | "source": [ 447 | "# Ejercicio 69\n", 448 | "\n", 449 | "Sumar un rango con 15 valores a un arreglo de fechas que contienela fecha 2019-09-12." 450 | ] 451 | }, 452 | { 453 | "cell_type": "markdown", 454 | "metadata": {}, 455 | "source": [ 456 | "## Solución:" 457 | ] 458 | }, 459 | { 460 | "cell_type": "code", 461 | "execution_count": 20, 462 | "metadata": {}, 463 | "outputs": [], 464 | "source": [ 465 | "import numpy as np" 466 | ] 467 | }, 468 | { 469 | "cell_type": "code", 470 | "execution_count": 21, 471 | "metadata": {}, 472 | "outputs": [ 473 | { 474 | "data": { 475 | "text/plain": [ 476 | "array('2019-09-12', dtype='datetime64[D]')" 477 | ] 478 | }, 479 | "execution_count": 21, 480 | "metadata": {}, 481 | "output_type": "execute_result" 482 | } 483 | ], 484 | "source": [ 485 | "fechas = np.array('2019-09-12', dtype=np.datetime64)\n", 486 | "fechas" 487 | ] 488 | }, 489 | { 490 | "cell_type": "code", 491 | "execution_count": 22, 492 | "metadata": {}, 493 | "outputs": [ 494 | { 495 | "data": { 496 | "text/plain": [ 497 | "array(['2019-09-12', '2019-09-13', '2019-09-14', '2019-09-15',\n", 498 | " '2019-09-16', '2019-09-17', '2019-09-18', '2019-09-19',\n", 499 | " '2019-09-20', '2019-09-21', '2019-09-22', '2019-09-23',\n", 500 | " '2019-09-24', '2019-09-25', '2019-09-26'], dtype='datetime64[D]')" 501 | ] 502 | }, 503 | "execution_count": 22, 504 | "metadata": {}, 505 | "output_type": "execute_result" 506 | } 507 | ], 508 | "source": [ 509 | "fechas + np.arange(15)" 510 | ] 511 | }, 512 | { 513 | "cell_type": "markdown", 514 | "metadata": {}, 515 | "source": [ 516 | "# Ejercicio 70\n", 517 | "\n", 518 | "Convertir una fecha arbitraria de tipo `datetime64` (NumPy) a un objeto `datetime` (Python)." 519 | ] 520 | }, 521 | { 522 | "cell_type": "markdown", 523 | "metadata": {}, 524 | "source": [ 525 | "## Solución:" 526 | ] 527 | }, 528 | { 529 | "cell_type": "code", 530 | "execution_count": 23, 531 | "metadata": {}, 532 | "outputs": [], 533 | "source": [ 534 | "import numpy as np" 535 | ] 536 | }, 537 | { 538 | "cell_type": "code", 539 | "execution_count": 24, 540 | "metadata": {}, 541 | "outputs": [ 542 | { 543 | "data": { 544 | "text/plain": [ 545 | "numpy.datetime64('2019-05-19T21:14:31')" 546 | ] 547 | }, 548 | "execution_count": 24, 549 | "metadata": {}, 550 | "output_type": "execute_result" 551 | } 552 | ], 553 | "source": [ 554 | "fecha_np = np.datetime64('2019-05-19 21:14:31')\n", 555 | "fecha_np" 556 | ] 557 | }, 558 | { 559 | "cell_type": "code", 560 | "execution_count": 25, 561 | "metadata": {}, 562 | "outputs": [], 563 | "source": [ 564 | "from datetime import datetime" 565 | ] 566 | }, 567 | { 568 | "cell_type": "code", 569 | "execution_count": 26, 570 | "metadata": {}, 571 | "outputs": [ 572 | { 573 | "data": { 574 | "text/plain": [ 575 | "datetime.datetime(2019, 5, 19, 21, 14, 31)" 576 | ] 577 | }, 578 | "execution_count": 26, 579 | "metadata": {}, 580 | "output_type": "execute_result" 581 | } 582 | ], 583 | "source": [ 584 | "fecha_np.tolist()" 585 | ] 586 | }, 587 | { 588 | "cell_type": "code", 589 | "execution_count": 27, 590 | "metadata": {}, 591 | "outputs": [ 592 | { 593 | "data": { 594 | "text/plain": [ 595 | "datetime.datetime(2019, 5, 19, 21, 14, 31)" 596 | ] 597 | }, 598 | "execution_count": 27, 599 | "metadata": {}, 600 | "output_type": "execute_result" 601 | } 602 | ], 603 | "source": [ 604 | "fecha_np.astype(datetime)" 605 | ] 606 | } 607 | ], 608 | "metadata": { 609 | "kernelspec": { 610 | "display_name": "Python 3", 611 | "language": "python", 612 | "name": "python3" 613 | }, 614 | "language_info": { 615 | "codemirror_mode": { 616 | "name": "ipython", 617 | "version": 3 618 | }, 619 | "file_extension": ".py", 620 | "mimetype": "text/x-python", 621 | "name": "python", 622 | "nbconvert_exporter": "python", 623 | "pygments_lexer": "ipython3", 624 | "version": "3.7.1" 625 | } 626 | }, 627 | "nbformat": 4, 628 | "nbformat_minor": 2 629 | } 630 | -------------------------------------------------------------------------------- /NumPy-Ejercicios-Serie5.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Ejercicio 148\n", 8 | "\n", 9 | "Computar la multiplicación de dos matrices arbitrarias." 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "## Solución:" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 1, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "import numpy as np" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 2, 31 | "metadata": {}, 32 | "outputs": [ 33 | { 34 | "data": { 35 | "text/plain": [ 36 | "[[2, 3], [5, 7]]" 37 | ] 38 | }, 39 | "execution_count": 2, 40 | "metadata": {}, 41 | "output_type": "execute_result" 42 | } 43 | ], 44 | "source": [ 45 | "a = [[2, 3], [5, 7]]\n", 46 | "a" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": 3, 52 | "metadata": {}, 53 | "outputs": [ 54 | { 55 | "data": { 56 | "text/plain": [ 57 | "[[4, 2], [3, 5]]" 58 | ] 59 | }, 60 | "execution_count": 3, 61 | "metadata": {}, 62 | "output_type": "execute_result" 63 | } 64 | ], 65 | "source": [ 66 | "b = [[4, 2], [3, 5]]\n", 67 | "b" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": 4, 73 | "metadata": {}, 74 | "outputs": [ 75 | { 76 | "data": { 77 | "text/plain": [ 78 | "array([[17, 19],\n", 79 | " [41, 45]])" 80 | ] 81 | }, 82 | "execution_count": 4, 83 | "metadata": {}, 84 | "output_type": "execute_result" 85 | } 86 | ], 87 | "source": [ 88 | "np.dot(a, b)" 89 | ] 90 | }, 91 | { 92 | "cell_type": "markdown", 93 | "metadata": {}, 94 | "source": [ 95 | "# Ejercicio 149\n", 96 | "\n", 97 | "Calcular el producto externo de dos vectores." 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "## Solución:" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 5, 110 | "metadata": {}, 111 | "outputs": [], 112 | "source": [ 113 | "import numpy as np" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": 6, 119 | "metadata": {}, 120 | "outputs": [ 121 | { 122 | "data": { 123 | "text/plain": [ 124 | "[[2, 2], [1, 2]]" 125 | ] 126 | }, 127 | "execution_count": 6, 128 | "metadata": {}, 129 | "output_type": "execute_result" 130 | } 131 | ], 132 | "source": [ 133 | "a = [[2, 2], [1, 2]]\n", 134 | "b = [[0, 1], [4, 0]]\n", 135 | "\n", 136 | "a" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": 7, 142 | "metadata": {}, 143 | "outputs": [ 144 | { 145 | "data": { 146 | "text/plain": [ 147 | "[[0, 1], [4, 0]]" 148 | ] 149 | }, 150 | "execution_count": 7, 151 | "metadata": {}, 152 | "output_type": "execute_result" 153 | } 154 | ], 155 | "source": [ 156 | "b" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": 8, 162 | "metadata": {}, 163 | "outputs": [ 164 | { 165 | "data": { 166 | "text/plain": [ 167 | "array([[0, 2, 8, 0],\n", 168 | " [0, 2, 8, 0],\n", 169 | " [0, 1, 4, 0],\n", 170 | " [0, 2, 8, 0]])" 171 | ] 172 | }, 173 | "execution_count": 8, 174 | "metadata": {}, 175 | "output_type": "execute_result" 176 | } 177 | ], 178 | "source": [ 179 | "np.outer(a, b)" 180 | ] 181 | }, 182 | { 183 | "cell_type": "markdown", 184 | "metadata": {}, 185 | "source": [ 186 | "# Ejercicio 150\n", 187 | "\n", 188 | "Computar el producto cruz entre dos vectores arbitrarios." 189 | ] 190 | }, 191 | { 192 | "cell_type": "markdown", 193 | "metadata": {}, 194 | "source": [ 195 | "## Solución:" 196 | ] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": 9, 201 | "metadata": {}, 202 | "outputs": [], 203 | "source": [ 204 | "import numpy as np" 205 | ] 206 | }, 207 | { 208 | "cell_type": "code", 209 | "execution_count": 10, 210 | "metadata": {}, 211 | "outputs": [ 212 | { 213 | "data": { 214 | "text/plain": [ 215 | "[[1, 3], [4, 3]]" 216 | ] 217 | }, 218 | "execution_count": 10, 219 | "metadata": {}, 220 | "output_type": "execute_result" 221 | } 222 | ], 223 | "source": [ 224 | "p = [[1, 3], [4, 3]]\n", 225 | "q = [[5, 9], [3, 2]]\n", 226 | "\n", 227 | "p" 228 | ] 229 | }, 230 | { 231 | "cell_type": "code", 232 | "execution_count": 11, 233 | "metadata": {}, 234 | "outputs": [ 235 | { 236 | "data": { 237 | "text/plain": [ 238 | "[[5, 9], [3, 2]]" 239 | ] 240 | }, 241 | "execution_count": 11, 242 | "metadata": {}, 243 | "output_type": "execute_result" 244 | } 245 | ], 246 | "source": [ 247 | "q" 248 | ] 249 | }, 250 | { 251 | "cell_type": "code", 252 | "execution_count": 12, 253 | "metadata": {}, 254 | "outputs": [ 255 | { 256 | "data": { 257 | "text/plain": [ 258 | "array([-6, -1])" 259 | ] 260 | }, 261 | "execution_count": 12, 262 | "metadata": {}, 263 | "output_type": "execute_result" 264 | } 265 | ], 266 | "source": [ 267 | "np.cross(p, q)" 268 | ] 269 | }, 270 | { 271 | "cell_type": "code", 272 | "execution_count": 13, 273 | "metadata": {}, 274 | "outputs": [ 275 | { 276 | "data": { 277 | "text/plain": [ 278 | "array([6, 1])" 279 | ] 280 | }, 281 | "execution_count": 13, 282 | "metadata": {}, 283 | "output_type": "execute_result" 284 | } 285 | ], 286 | "source": [ 287 | "np.cross(q, p)" 288 | ] 289 | }, 290 | { 291 | "cell_type": "markdown", 292 | "metadata": {}, 293 | "source": [ 294 | "# Ejercicio 151\n", 295 | "\n", 296 | "Computar el determinante de una matriz." 297 | ] 298 | }, 299 | { 300 | "cell_type": "markdown", 301 | "metadata": {}, 302 | "source": [ 303 | "## Solución:" 304 | ] 305 | }, 306 | { 307 | "cell_type": "code", 308 | "execution_count": 14, 309 | "metadata": {}, 310 | "outputs": [], 311 | "source": [ 312 | "import numpy as np" 313 | ] 314 | }, 315 | { 316 | "cell_type": "code", 317 | "execution_count": 15, 318 | "metadata": {}, 319 | "outputs": [ 320 | { 321 | "data": { 322 | "text/plain": [ 323 | "array([[2, 3, 4],\n", 324 | " [5, 7, 8],\n", 325 | " [2, 3, 5]])" 326 | ] 327 | }, 328 | "execution_count": 15, 329 | "metadata": {}, 330 | "output_type": "execute_result" 331 | } 332 | ], 333 | "source": [ 334 | "m = np.array([[2, 3, 4], [5, 7, 8], [2, 3, 5]])\n", 335 | "\n", 336 | "m" 337 | ] 338 | }, 339 | { 340 | "cell_type": "code", 341 | "execution_count": 16, 342 | "metadata": {}, 343 | "outputs": [ 344 | { 345 | "data": { 346 | "text/plain": [ 347 | "-0.9999999999999991" 348 | ] 349 | }, 350 | "execution_count": 16, 351 | "metadata": {}, 352 | "output_type": "execute_result" 353 | } 354 | ], 355 | "source": [ 356 | "np.linalg.det(m)" 357 | ] 358 | }, 359 | { 360 | "cell_type": "markdown", 361 | "metadata": {}, 362 | "source": [ 363 | "# Ejercicio 152\n", 364 | "\n", 365 | "Calcula la suma de Einstein para dos vectores." 366 | ] 367 | }, 368 | { 369 | "cell_type": "markdown", 370 | "metadata": {}, 371 | "source": [ 372 | "## Solución:" 373 | ] 374 | }, 375 | { 376 | "cell_type": "code", 377 | "execution_count": 17, 378 | "metadata": {}, 379 | "outputs": [], 380 | "source": [ 381 | "import numpy as np" 382 | ] 383 | }, 384 | { 385 | "cell_type": "code", 386 | "execution_count": 18, 387 | "metadata": {}, 388 | "outputs": [ 389 | { 390 | "data": { 391 | "text/plain": [ 392 | "(array([2, 3, 4]), array([5, 3, 2]))" 393 | ] 394 | }, 395 | "execution_count": 18, 396 | "metadata": {}, 397 | "output_type": "execute_result" 398 | } 399 | ], 400 | "source": [ 401 | "a = np.array([2, 3, 4])\n", 402 | "b = np.array([5, 3, 2])\n", 403 | "\n", 404 | "a, b" 405 | ] 406 | }, 407 | { 408 | "cell_type": "code", 409 | "execution_count": 19, 410 | "metadata": {}, 411 | "outputs": [ 412 | { 413 | "data": { 414 | "text/plain": [ 415 | "27" 416 | ] 417 | }, 418 | "execution_count": 19, 419 | "metadata": {}, 420 | "output_type": "execute_result" 421 | } 422 | ], 423 | "source": [ 424 | "np.einsum(\"n,n\", a, b)" 425 | ] 426 | }, 427 | { 428 | "cell_type": "markdown", 429 | "metadata": {}, 430 | "source": [ 431 | "# Ejercicio 153\n", 432 | "\n", 433 | "Computar el producto interno de dos vectores unidimensionales." 434 | ] 435 | }, 436 | { 437 | "cell_type": "markdown", 438 | "metadata": {}, 439 | "source": [ 440 | "## Solución:" 441 | ] 442 | }, 443 | { 444 | "cell_type": "code", 445 | "execution_count": 20, 446 | "metadata": {}, 447 | "outputs": [], 448 | "source": [ 449 | "import numpy as np" 450 | ] 451 | }, 452 | { 453 | "cell_type": "code", 454 | "execution_count": 21, 455 | "metadata": {}, 456 | "outputs": [ 457 | { 458 | "data": { 459 | "text/plain": [ 460 | "(array([2, 3, 5]), array([3, 8, 7]))" 461 | ] 462 | }, 463 | "execution_count": 21, 464 | "metadata": {}, 465 | "output_type": "execute_result" 466 | } 467 | ], 468 | "source": [ 469 | "a = np.array([2, 3, 5])\n", 470 | "b = np.array([3, 8, 7])\n", 471 | "\n", 472 | "a, b" 473 | ] 474 | }, 475 | { 476 | "cell_type": "code", 477 | "execution_count": 22, 478 | "metadata": {}, 479 | "outputs": [ 480 | { 481 | "data": { 482 | "text/plain": [ 483 | "65" 484 | ] 485 | }, 486 | "execution_count": 22, 487 | "metadata": {}, 488 | "output_type": "execute_result" 489 | } 490 | ], 491 | "source": [ 492 | "np.inner(a, b)" 493 | ] 494 | }, 495 | { 496 | "cell_type": "markdown", 497 | "metadata": {}, 498 | "source": [ 499 | "# Ejercicio 154\n", 500 | "\n", 501 | "Computar los valores y vectores propios de una matriz." 502 | ] 503 | }, 504 | { 505 | "cell_type": "markdown", 506 | "metadata": {}, 507 | "source": [ 508 | "## Solución:" 509 | ] 510 | }, 511 | { 512 | "cell_type": "code", 513 | "execution_count": 23, 514 | "metadata": {}, 515 | "outputs": [], 516 | "source": [ 517 | "import numpy as np" 518 | ] 519 | }, 520 | { 521 | "cell_type": "code", 522 | "execution_count": 24, 523 | "metadata": {}, 524 | "outputs": [ 525 | { 526 | "data": { 527 | "text/plain": [ 528 | "array([[2, 5, 3],\n", 529 | " [9, 5, 8],\n", 530 | " [2, 3, 8]])" 531 | ] 532 | }, 533 | "execution_count": 24, 534 | "metadata": {}, 535 | "output_type": "execute_result" 536 | } 537 | ], 538 | "source": [ 539 | "m = np.array([[2, 5, 3], [9, 5, 8], [2, 3, 8]])\n", 540 | "\n", 541 | "m" 542 | ] 543 | }, 544 | { 545 | "cell_type": "code", 546 | "execution_count": 25, 547 | "metadata": {}, 548 | "outputs": [ 549 | { 550 | "data": { 551 | "text/plain": [ 552 | "array([14.70064048, -3.51408616, 3.81344568])" 553 | ] 554 | }, 555 | "execution_count": 25, 556 | "metadata": {}, 557 | "output_type": "execute_result" 558 | } 559 | ], 560 | "source": [ 561 | "valores, vectores = np.linalg.eig(m)\n", 562 | "\n", 563 | "valores" 564 | ] 565 | }, 566 | { 567 | "cell_type": "code", 568 | "execution_count": 26, 569 | "metadata": {}, 570 | "outputs": [ 571 | { 572 | "data": { 573 | "text/plain": [ 574 | "array([[-0.41722955, -0.64293927, -0.50177578],\n", 575 | " [-0.77650312, 0.76100543, -0.57155045],\n", 576 | " [-0.47218896, -0.08660156, 0.64926971]])" 577 | ] 578 | }, 579 | "execution_count": 26, 580 | "metadata": {}, 581 | "output_type": "execute_result" 582 | } 583 | ], 584 | "source": [ 585 | "vectores" 586 | ] 587 | }, 588 | { 589 | "cell_type": "markdown", 590 | "metadata": {}, 591 | "source": [ 592 | "# Ejercicio 155\n", 593 | "\n", 594 | "Calcular el producto de Kronecker entre dos arreglos." 595 | ] 596 | }, 597 | { 598 | "cell_type": "markdown", 599 | "metadata": {}, 600 | "source": [ 601 | "## Solución:" 602 | ] 603 | }, 604 | { 605 | "cell_type": "code", 606 | "execution_count": 27, 607 | "metadata": {}, 608 | "outputs": [], 609 | "source": [ 610 | "import numpy as np" 611 | ] 612 | }, 613 | { 614 | "cell_type": "code", 615 | "execution_count": 28, 616 | "metadata": {}, 617 | "outputs": [ 618 | { 619 | "data": { 620 | "text/plain": [ 621 | "(array([5, 4, 3]), array([7, 3, 2]))" 622 | ] 623 | }, 624 | "execution_count": 28, 625 | "metadata": {}, 626 | "output_type": "execute_result" 627 | } 628 | ], 629 | "source": [ 630 | "a = np.array([5, 4, 3])\n", 631 | "b = np.array([7, 3, 2])\n", 632 | "\n", 633 | "a, b" 634 | ] 635 | }, 636 | { 637 | "cell_type": "code", 638 | "execution_count": 29, 639 | "metadata": {}, 640 | "outputs": [ 641 | { 642 | "data": { 643 | "text/plain": [ 644 | "array([35, 15, 10, 28, 12, 8, 21, 9, 6])" 645 | ] 646 | }, 647 | "execution_count": 29, 648 | "metadata": {}, 649 | "output_type": "execute_result" 650 | } 651 | ], 652 | "source": [ 653 | "np.kron(a, b)" 654 | ] 655 | }, 656 | { 657 | "cell_type": "markdown", 658 | "metadata": {}, 659 | "source": [ 660 | "# Ejercicio 156\n", 661 | "\n", 662 | "Calcular el número de condición para una matriz dada." 663 | ] 664 | }, 665 | { 666 | "cell_type": "markdown", 667 | "metadata": {}, 668 | "source": [ 669 | "## Solución:" 670 | ] 671 | }, 672 | { 673 | "cell_type": "code", 674 | "execution_count": 30, 675 | "metadata": {}, 676 | "outputs": [], 677 | "source": [ 678 | "import numpy as np" 679 | ] 680 | }, 681 | { 682 | "cell_type": "code", 683 | "execution_count": 31, 684 | "metadata": {}, 685 | "outputs": [ 686 | { 687 | "data": { 688 | "text/plain": [ 689 | "array([[2, 3, 4],\n", 690 | " [9, 5, 3],\n", 691 | " [8, 3, 1]])" 692 | ] 693 | }, 694 | "execution_count": 31, 695 | "metadata": {}, 696 | "output_type": "execute_result" 697 | } 698 | ], 699 | "source": [ 700 | "m = np.array([[2, 3, 4], [9, 5, 3], [8, 3, 1]])\n", 701 | "\n", 702 | "m" 703 | ] 704 | }, 705 | { 706 | "cell_type": "code", 707 | "execution_count": 32, 708 | "metadata": {}, 709 | "outputs": [ 710 | { 711 | "data": { 712 | "text/plain": [ 713 | "52.115439703156454" 714 | ] 715 | }, 716 | "execution_count": 32, 717 | "metadata": {}, 718 | "output_type": "execute_result" 719 | } 720 | ], 721 | "source": [ 722 | "np.linalg.cond(m)" 723 | ] 724 | }, 725 | { 726 | "cell_type": "markdown", 727 | "metadata": {}, 728 | "source": [ 729 | "# Ejercicio 157\n", 730 | "\n", 731 | "Computar la norma de un vector o una matriz." 732 | ] 733 | }, 734 | { 735 | "cell_type": "markdown", 736 | "metadata": {}, 737 | "source": [ 738 | "## Solución:" 739 | ] 740 | }, 741 | { 742 | "cell_type": "code", 743 | "execution_count": 33, 744 | "metadata": {}, 745 | "outputs": [], 746 | "source": [ 747 | "import numpy as np" 748 | ] 749 | }, 750 | { 751 | "cell_type": "code", 752 | "execution_count": 34, 753 | "metadata": {}, 754 | "outputs": [ 755 | { 756 | "data": { 757 | "text/plain": [ 758 | "array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])" 759 | ] 760 | }, 761 | "execution_count": 34, 762 | "metadata": {}, 763 | "output_type": "execute_result" 764 | } 765 | ], 766 | "source": [ 767 | "v = np.arange(1, 13)\n", 768 | "v" 769 | ] 770 | }, 771 | { 772 | "cell_type": "code", 773 | "execution_count": 35, 774 | "metadata": {}, 775 | "outputs": [ 776 | { 777 | "data": { 778 | "text/plain": [ 779 | "25.495097567963924" 780 | ] 781 | }, 782 | "execution_count": 35, 783 | "metadata": {}, 784 | "output_type": "execute_result" 785 | } 786 | ], 787 | "source": [ 788 | "np.linalg.norm(v)" 789 | ] 790 | }, 791 | { 792 | "cell_type": "code", 793 | "execution_count": 36, 794 | "metadata": {}, 795 | "outputs": [ 796 | { 797 | "data": { 798 | "text/plain": [ 799 | "array([[1, 2, 3],\n", 800 | " [4, 5, 6],\n", 801 | " [7, 8, 9]])" 802 | ] 803 | }, 804 | "execution_count": 36, 805 | "metadata": {}, 806 | "output_type": "execute_result" 807 | } 808 | ], 809 | "source": [ 810 | "m = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n", 811 | "m" 812 | ] 813 | }, 814 | { 815 | "cell_type": "code", 816 | "execution_count": 37, 817 | "metadata": {}, 818 | "outputs": [ 819 | { 820 | "data": { 821 | "text/plain": [ 822 | "16.881943016134134" 823 | ] 824 | }, 825 | "execution_count": 37, 826 | "metadata": {}, 827 | "output_type": "execute_result" 828 | } 829 | ], 830 | "source": [ 831 | "np.linalg.norm(m)" 832 | ] 833 | }, 834 | { 835 | "cell_type": "markdown", 836 | "metadata": {}, 837 | "source": [ 838 | "# Ejercicio 158\n", 839 | "\n", 840 | "Computar el determinante de una matriz arbitraria (nxn)." 841 | ] 842 | }, 843 | { 844 | "cell_type": "markdown", 845 | "metadata": {}, 846 | "source": [ 847 | "## Solución:" 848 | ] 849 | }, 850 | { 851 | "cell_type": "code", 852 | "execution_count": 38, 853 | "metadata": {}, 854 | "outputs": [], 855 | "source": [ 856 | "import numpy as np" 857 | ] 858 | }, 859 | { 860 | "cell_type": "code", 861 | "execution_count": 39, 862 | "metadata": {}, 863 | "outputs": [ 864 | { 865 | "data": { 866 | "text/plain": [ 867 | "array([[4, 3, 1],\n", 868 | " [8, 9, 3],\n", 869 | " [4, 7, 9]])" 870 | ] 871 | }, 872 | "execution_count": 39, 873 | "metadata": {}, 874 | "output_type": "execute_result" 875 | } 876 | ], 877 | "source": [ 878 | "m = np.array([[4, 3, 1], [8, 9, 3], [4, 7, 9]])\n", 879 | "m" 880 | ] 881 | }, 882 | { 883 | "cell_type": "code", 884 | "execution_count": 40, 885 | "metadata": {}, 886 | "outputs": [ 887 | { 888 | "data": { 889 | "text/plain": [ 890 | "79.99999999999997" 891 | ] 892 | }, 893 | "execution_count": 40, 894 | "metadata": {}, 895 | "output_type": "execute_result" 896 | } 897 | ], 898 | "source": [ 899 | "np.linalg.det(m)" 900 | ] 901 | }, 902 | { 903 | "cell_type": "markdown", 904 | "metadata": {}, 905 | "source": [ 906 | "# Ejercicio 159\n", 907 | "\n", 908 | "Computar el inverso de una matriz dada." 909 | ] 910 | }, 911 | { 912 | "cell_type": "markdown", 913 | "metadata": {}, 914 | "source": [ 915 | "## Solución:" 916 | ] 917 | }, 918 | { 919 | "cell_type": "code", 920 | "execution_count": 41, 921 | "metadata": {}, 922 | "outputs": [], 923 | "source": [ 924 | "import numpy as np" 925 | ] 926 | }, 927 | { 928 | "cell_type": "code", 929 | "execution_count": 42, 930 | "metadata": {}, 931 | "outputs": [ 932 | { 933 | "data": { 934 | "text/plain": [ 935 | "array([[3, 2, 1],\n", 936 | " [7, 5, 3],\n", 937 | " [7, 4, 5]])" 938 | ] 939 | }, 940 | "execution_count": 42, 941 | "metadata": {}, 942 | "output_type": "execute_result" 943 | } 944 | ], 945 | "source": [ 946 | "m = np.array([[3, 2, 1], [7, 5, 3], [7, 4, 5]])\n", 947 | "m" 948 | ] 949 | }, 950 | { 951 | "cell_type": "code", 952 | "execution_count": 43, 953 | "metadata": {}, 954 | "outputs": [ 955 | { 956 | "data": { 957 | "text/plain": [ 958 | "array([[ 3.25, -1.5 , 0.25],\n", 959 | " [-3.5 , 2. , -0.5 ],\n", 960 | " [-1.75, 0.5 , 0.25]])" 961 | ] 962 | }, 963 | "execution_count": 43, 964 | "metadata": {}, 965 | "output_type": "execute_result" 966 | } 967 | ], 968 | "source": [ 969 | "np.linalg.inv(m)" 970 | ] 971 | }, 972 | { 973 | "cell_type": "markdown", 974 | "metadata": {}, 975 | "source": [ 976 | "# Ejercicio 160\n", 977 | "\n", 978 | "Computar la factorización QR de una matriz dada." 979 | ] 980 | }, 981 | { 982 | "cell_type": "markdown", 983 | "metadata": {}, 984 | "source": [ 985 | "## Solución:" 986 | ] 987 | }, 988 | { 989 | "cell_type": "code", 990 | "execution_count": 44, 991 | "metadata": {}, 992 | "outputs": [], 993 | "source": [ 994 | "import numpy as np" 995 | ] 996 | }, 997 | { 998 | "cell_type": "code", 999 | "execution_count": 45, 1000 | "metadata": {}, 1001 | "outputs": [ 1002 | { 1003 | "data": { 1004 | "text/plain": [ 1005 | "array([[3, 7, 5],\n", 1006 | " [7, 4, 5],\n", 1007 | " [2, 3, 5]])" 1008 | ] 1009 | }, 1010 | "execution_count": 45, 1011 | "metadata": {}, 1012 | "output_type": "execute_result" 1013 | } 1014 | ], 1015 | "source": [ 1016 | "m = np.array([[3, 7, 5], [7, 4, 5], [2, 3, 5]])\n", 1017 | "m" 1018 | ] 1019 | }, 1020 | { 1021 | "cell_type": "code", 1022 | "execution_count": 46, 1023 | "metadata": {}, 1024 | "outputs": [ 1025 | { 1026 | "data": { 1027 | "text/plain": [ 1028 | "(array([[-0.38100038, 0.86412575, -0.32882427],\n", 1029 | " [-0.88900089, -0.44009378, -0.12647087],\n", 1030 | " [-0.25400025, 0.24413962, 0.93588446]]),\n", 1031 | " array([[-7.87400787, -6.98500699, -7.62000762],\n", 1032 | " [ 0. , 5.02092396, 3.34085791],\n", 1033 | " [ 0. , 0. , 2.40294658]]))" 1034 | ] 1035 | }, 1036 | "execution_count": 46, 1037 | "metadata": {}, 1038 | "output_type": "execute_result" 1039 | } 1040 | ], 1041 | "source": [ 1042 | "np.linalg.qr(m)" 1043 | ] 1044 | }, 1045 | { 1046 | "cell_type": "markdown", 1047 | "metadata": {}, 1048 | "source": [ 1049 | "# Ejercicio 161\n", 1050 | "\n", 1051 | "Computar la traza de una matriz." 1052 | ] 1053 | }, 1054 | { 1055 | "cell_type": "markdown", 1056 | "metadata": {}, 1057 | "source": [ 1058 | "## Solución:" 1059 | ] 1060 | }, 1061 | { 1062 | "cell_type": "code", 1063 | "execution_count": 47, 1064 | "metadata": {}, 1065 | "outputs": [], 1066 | "source": [ 1067 | "import numpy as np" 1068 | ] 1069 | }, 1070 | { 1071 | "cell_type": "code", 1072 | "execution_count": 48, 1073 | "metadata": {}, 1074 | "outputs": [ 1075 | { 1076 | "data": { 1077 | "text/plain": [ 1078 | "array([[3, 2, 1],\n", 1079 | " [5, 7, 9],\n", 1080 | " [8, 5, 1]])" 1081 | ] 1082 | }, 1083 | "execution_count": 48, 1084 | "metadata": {}, 1085 | "output_type": "execute_result" 1086 | } 1087 | ], 1088 | "source": [ 1089 | "m = np.array([[3, 2, 1], [5, 7, 9], [8, 5, 1]])\n", 1090 | "m" 1091 | ] 1092 | }, 1093 | { 1094 | "cell_type": "code", 1095 | "execution_count": 49, 1096 | "metadata": {}, 1097 | "outputs": [ 1098 | { 1099 | "data": { 1100 | "text/plain": [ 1101 | "11" 1102 | ] 1103 | }, 1104 | "execution_count": 49, 1105 | "metadata": {}, 1106 | "output_type": "execute_result" 1107 | } 1108 | ], 1109 | "source": [ 1110 | "np.trace(m)" 1111 | ] 1112 | }, 1113 | { 1114 | "cell_type": "code", 1115 | "execution_count": 50, 1116 | "metadata": {}, 1117 | "outputs": [ 1118 | { 1119 | "data": { 1120 | "text/plain": [ 1121 | "10" 1122 | ] 1123 | }, 1124 | "execution_count": 50, 1125 | "metadata": {}, 1126 | "output_type": "execute_result" 1127 | } 1128 | ], 1129 | "source": [ 1130 | "np.trace(m, -1)" 1131 | ] 1132 | }, 1133 | { 1134 | "cell_type": "markdown", 1135 | "metadata": {}, 1136 | "source": [ 1137 | "# Ejercicio 162\n", 1138 | "\n", 1139 | "Computar el factor de una matriz a partir de la descomposición en valores singulares." 1140 | ] 1141 | }, 1142 | { 1143 | "cell_type": "markdown", 1144 | "metadata": {}, 1145 | "source": [ 1146 | "## Solución:" 1147 | ] 1148 | }, 1149 | { 1150 | "cell_type": "code", 1151 | "execution_count": 51, 1152 | "metadata": {}, 1153 | "outputs": [], 1154 | "source": [ 1155 | "import numpy as np" 1156 | ] 1157 | }, 1158 | { 1159 | "cell_type": "code", 1160 | "execution_count": 52, 1161 | "metadata": {}, 1162 | "outputs": [ 1163 | { 1164 | "data": { 1165 | "text/plain": [ 1166 | "array([[1., 0., 0., 0., 2.],\n", 1167 | " [0., 0., 3., 0., 0.],\n", 1168 | " [0., 0., 0., 0., 0.],\n", 1169 | " [0., 2., 0., 0., 0.]], dtype=float32)" 1170 | ] 1171 | }, 1172 | "execution_count": 52, 1173 | "metadata": {}, 1174 | "output_type": "execute_result" 1175 | } 1176 | ], 1177 | "source": [ 1178 | "m = np.array([[1, 0, 0, 0, 2], [0, 0, 3, 0, 0], [0, 0, 0, 0, 0], [0, 2, 0, 0, 0]], dtype=np.float32)\n", 1179 | "\n", 1180 | "m" 1181 | ] 1182 | }, 1183 | { 1184 | "cell_type": "code", 1185 | "execution_count": 53, 1186 | "metadata": {}, 1187 | "outputs": [], 1188 | "source": [ 1189 | "U, s, V = np.linalg.svd(m, full_matrices=False)" 1190 | ] 1191 | }, 1192 | { 1193 | "cell_type": "code", 1194 | "execution_count": 54, 1195 | "metadata": {}, 1196 | "outputs": [ 1197 | { 1198 | "data": { 1199 | "text/plain": [ 1200 | "array([[ 0., 1., 0., 0.],\n", 1201 | " [ 1., 0., 0., 0.],\n", 1202 | " [ 0., 0., 0., -1.],\n", 1203 | " [ 0., 0., 1., 0.]], dtype=float32)" 1204 | ] 1205 | }, 1206 | "execution_count": 54, 1207 | "metadata": {}, 1208 | "output_type": "execute_result" 1209 | } 1210 | ], 1211 | "source": [ 1212 | "U" 1213 | ] 1214 | }, 1215 | { 1216 | "cell_type": "markdown", 1217 | "metadata": {}, 1218 | "source": [ 1219 | "# Ejercicio 163\n", 1220 | "\n", 1221 | "Computar la norma y el número de condición de Frobenius." 1222 | ] 1223 | }, 1224 | { 1225 | "cell_type": "markdown", 1226 | "metadata": {}, 1227 | "source": [ 1228 | "## Solución:" 1229 | ] 1230 | }, 1231 | { 1232 | "cell_type": "code", 1233 | "execution_count": 55, 1234 | "metadata": {}, 1235 | "outputs": [], 1236 | "source": [ 1237 | "import numpy as np" 1238 | ] 1239 | }, 1240 | { 1241 | "cell_type": "code", 1242 | "execution_count": 56, 1243 | "metadata": {}, 1244 | "outputs": [ 1245 | { 1246 | "data": { 1247 | "text/plain": [ 1248 | "array([[ 1, 2, 3, 4],\n", 1249 | " [ 5, 6, 7, 8],\n", 1250 | " [ 9, 10, 11, 12],\n", 1251 | " [13, 14, 15, 16]])" 1252 | ] 1253 | }, 1254 | "execution_count": 56, 1255 | "metadata": {}, 1256 | "output_type": "execute_result" 1257 | } 1258 | ], 1259 | "source": [ 1260 | "m = np.arange(1, 17).reshape(4, 4)\n", 1261 | "\n", 1262 | "m" 1263 | ] 1264 | }, 1265 | { 1266 | "cell_type": "code", 1267 | "execution_count": 57, 1268 | "metadata": {}, 1269 | "outputs": [ 1270 | { 1271 | "data": { 1272 | "text/plain": [ 1273 | "38.67815921162743" 1274 | ] 1275 | }, 1276 | "execution_count": 57, 1277 | "metadata": {}, 1278 | "output_type": "execute_result" 1279 | } 1280 | ], 1281 | "source": [ 1282 | "np.linalg.norm(m, 'fro')" 1283 | ] 1284 | }, 1285 | { 1286 | "cell_type": "code", 1287 | "execution_count": 58, 1288 | "metadata": {}, 1289 | "outputs": [ 1290 | { 1291 | "data": { 1292 | "text/plain": [ 1293 | "3.210478703559863e+18" 1294 | ] 1295 | }, 1296 | "execution_count": 58, 1297 | "metadata": {}, 1298 | "output_type": "execute_result" 1299 | } 1300 | ], 1301 | "source": [ 1302 | "np.linalg.cond(m, 'fro')" 1303 | ] 1304 | }, 1305 | { 1306 | "cell_type": "markdown", 1307 | "metadata": {}, 1308 | "source": [ 1309 | "# Ejercicio 164\n", 1310 | "\n", 1311 | "Computar la matriz triangular inferior L usando la factorización de Cholesky." 1312 | ] 1313 | }, 1314 | { 1315 | "cell_type": "markdown", 1316 | "metadata": {}, 1317 | "source": [ 1318 | "## Solución" 1319 | ] 1320 | }, 1321 | { 1322 | "cell_type": "code", 1323 | "execution_count": 59, 1324 | "metadata": {}, 1325 | "outputs": [], 1326 | "source": [ 1327 | "import numpy as np" 1328 | ] 1329 | }, 1330 | { 1331 | "cell_type": "code", 1332 | "execution_count": 60, 1333 | "metadata": {}, 1334 | "outputs": [ 1335 | { 1336 | "data": { 1337 | "text/plain": [ 1338 | "array([[ 4, 12, -16],\n", 1339 | " [ 12, 37, -43],\n", 1340 | " [-16, -43, 98]])" 1341 | ] 1342 | }, 1343 | "execution_count": 60, 1344 | "metadata": {}, 1345 | "output_type": "execute_result" 1346 | } 1347 | ], 1348 | "source": [ 1349 | "m = np.array([[4, 12, -16], [12, 37, -43], [-16, -43, 98]])\n", 1350 | "\n", 1351 | "m" 1352 | ] 1353 | }, 1354 | { 1355 | "cell_type": "code", 1356 | "execution_count": 61, 1357 | "metadata": {}, 1358 | "outputs": [ 1359 | { 1360 | "data": { 1361 | "text/plain": [ 1362 | "array([[ 2., 0., 0.],\n", 1363 | " [ 6., 1., 0.],\n", 1364 | " [-8., 5., 3.]])" 1365 | ] 1366 | }, 1367 | "execution_count": 61, 1368 | "metadata": {}, 1369 | "output_type": "execute_result" 1370 | } 1371 | ], 1372 | "source": [ 1373 | "np.linalg.cholesky(m)" 1374 | ] 1375 | } 1376 | ], 1377 | "metadata": { 1378 | "kernelspec": { 1379 | "display_name": "Python 3", 1380 | "language": "python", 1381 | "name": "python3" 1382 | }, 1383 | "language_info": { 1384 | "codemirror_mode": { 1385 | "name": "ipython", 1386 | "version": 3 1387 | }, 1388 | "file_extension": ".py", 1389 | "mimetype": "text/x-python", 1390 | "name": "python", 1391 | "nbconvert_exporter": "python", 1392 | "pygments_lexer": "ipython3", 1393 | "version": "3.7.1" 1394 | } 1395 | }, 1396 | "nbformat": 4, 1397 | "nbformat_minor": 2 1398 | } 1399 | -------------------------------------------------------------------------------- /NumPy-Ejercicios-Serie6.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Ejercicio 165\n", 8 | "\n", 9 | "Generar 10 números aleatorios a partir de una distribución normal." 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "## Solución:" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 1, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "import numpy as np" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 2, 31 | "metadata": {}, 32 | "outputs": [ 33 | { 34 | "data": { 35 | "text/plain": [ 36 | "array([-1.06887592, -0.03187524, 1.47892606, -0.86922781, -1.40688985,\n", 37 | " -0.75154757, -0.36604557, -2.2337027 , -0.20955504, -0.96075768])" 38 | ] 39 | }, 40 | "execution_count": 2, 41 | "metadata": {}, 42 | "output_type": "execute_result" 43 | } 44 | ], 45 | "source": [ 46 | "arreglo = np.random.normal(size=10)\n", 47 | "\n", 48 | "arreglo" 49 | ] 50 | }, 51 | { 52 | "cell_type": "markdown", 53 | "metadata": {}, 54 | "source": [ 55 | "# Ejercicio 166\n", 56 | "\n", 57 | "Generar 10 valores enteros entre 1 y 30." 58 | ] 59 | }, 60 | { 61 | "cell_type": "markdown", 62 | "metadata": {}, 63 | "source": [ 64 | "## Solución:" 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": 3, 70 | "metadata": {}, 71 | "outputs": [], 72 | "source": [ 73 | "import numpy as np" 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": 4, 79 | "metadata": {}, 80 | "outputs": [ 81 | { 82 | "data": { 83 | "text/plain": [ 84 | "array([12, 16, 2, 16, 25, 26, 29, 14, 8, 29])" 85 | ] 86 | }, 87 | "execution_count": 4, 88 | "metadata": {}, 89 | "output_type": "execute_result" 90 | } 91 | ], 92 | "source": [ 93 | "np.random.randint(low=1, high=30, size=10)" 94 | ] 95 | }, 96 | { 97 | "cell_type": "markdown", 98 | "metadata": {}, 99 | "source": [ 100 | "# Ejercicio 167\n", 101 | "\n", 102 | "Generar un panel (cubo) de tamaño 4x4x4 que contenga números aleatorios." 103 | ] 104 | }, 105 | { 106 | "cell_type": "markdown", 107 | "metadata": {}, 108 | "source": [ 109 | "## Solución:" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": 5, 115 | "metadata": {}, 116 | "outputs": [], 117 | "source": [ 118 | "import numpy as np" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": 6, 124 | "metadata": {}, 125 | "outputs": [ 126 | { 127 | "data": { 128 | "text/plain": [ 129 | "array([[[0.52496645, 0.58363829, 0.25871867, 0.60308887],\n", 130 | " [0.55205983, 0.44430436, 0.28395769, 0.36390762],\n", 131 | " [0.61522471, 0.04214838, 0.5762407 , 0.7670476 ],\n", 132 | " [0.09706712, 0.44673486, 0.13466259, 0.27555656]],\n", 133 | "\n", 134 | " [[0.10572225, 0.24891622, 0.4517817 , 0.90424005],\n", 135 | " [0.31199521, 0.09151868, 0.1002408 , 0.33490124],\n", 136 | " [0.65859154, 0.51291323, 0.13251564, 0.87291355],\n", 137 | " [0.08937208, 0.51476334, 0.22842358, 0.5489599 ]],\n", 138 | "\n", 139 | " [[0.57163393, 0.52050507, 0.23431743, 0.37602816],\n", 140 | " [0.92371347, 0.2981394 , 0.16040589, 0.57353333],\n", 141 | " [0.02034896, 0.53480865, 0.00571434, 0.06436409],\n", 142 | " [0.13440857, 0.54137006, 0.38006384, 0.75786673]],\n", 143 | "\n", 144 | " [[0.7479763 , 0.7830116 , 0.80539608, 0.05460244],\n", 145 | " [0.15371591, 0.27397267, 0.45498309, 0.75997692],\n", 146 | " [0.23887472, 0.25758288, 0.11397708, 0.44586347],\n", 147 | " [0.2009914 , 0.24877352, 0.49242981, 0.39066757]]])" 148 | ] 149 | }, 150 | "execution_count": 6, 151 | "metadata": {}, 152 | "output_type": "execute_result" 153 | } 154 | ], 155 | "source": [ 156 | "panel = np.random.random((4, 4, 4))\n", 157 | "\n", 158 | "panel" 159 | ] 160 | }, 161 | { 162 | "cell_type": "markdown", 163 | "metadata": {}, 164 | "source": [ 165 | "# Ejercicio 168\n", 166 | "\n", 167 | "Crear una matriz de 4x4 con elementos aleatorios, y obtener el mínimo y el máximo de sus elementos." 168 | ] 169 | }, 170 | { 171 | "cell_type": "markdown", 172 | "metadata": {}, 173 | "source": [ 174 | "## Solución:" 175 | ] 176 | }, 177 | { 178 | "cell_type": "code", 179 | "execution_count": 7, 180 | "metadata": {}, 181 | "outputs": [], 182 | "source": [ 183 | "import numpy as np" 184 | ] 185 | }, 186 | { 187 | "cell_type": "code", 188 | "execution_count": 8, 189 | "metadata": {}, 190 | "outputs": [ 191 | { 192 | "data": { 193 | "text/plain": [ 194 | "array([[0.43565376, 0.76142883, 0.00153494, 0.72221542],\n", 195 | " [0.31560516, 0.46319064, 0.03310022, 0.62645212],\n", 196 | " [0.70661491, 0.37349807, 0.52730119, 0.14414834],\n", 197 | " [0.5374711 , 0.39477395, 0.84716902, 0.20019649]])" 198 | ] 199 | }, 200 | "execution_count": 8, 201 | "metadata": {}, 202 | "output_type": "execute_result" 203 | } 204 | ], 205 | "source": [ 206 | "m = np.random.random((4, 4))\n", 207 | "\n", 208 | "m" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": 9, 214 | "metadata": {}, 215 | "outputs": [ 216 | { 217 | "data": { 218 | "text/plain": [ 219 | "0.0015349401501595361" 220 | ] 221 | }, 222 | "execution_count": 9, 223 | "metadata": {}, 224 | "output_type": "execute_result" 225 | } 226 | ], 227 | "source": [ 228 | "m.min()" 229 | ] 230 | }, 231 | { 232 | "cell_type": "code", 233 | "execution_count": 10, 234 | "metadata": {}, 235 | "outputs": [ 236 | { 237 | "data": { 238 | "text/plain": [ 239 | "0.8471690190318865" 240 | ] 241 | }, 242 | "execution_count": 10, 243 | "metadata": {}, 244 | "output_type": "execute_result" 245 | } 246 | ], 247 | "source": [ 248 | "m.max()" 249 | ] 250 | }, 251 | { 252 | "cell_type": "markdown", 253 | "metadata": {}, 254 | "source": [ 255 | "# Ejercicio 169\n", 256 | "\n", 257 | "Crear una matriz de 15x15, y luego extraer las primeras 7 filas y almacernarlas en una variable." 258 | ] 259 | }, 260 | { 261 | "cell_type": "markdown", 262 | "metadata": {}, 263 | "source": [ 264 | "## Solución:" 265 | ] 266 | }, 267 | { 268 | "cell_type": "code", 269 | "execution_count": 11, 270 | "metadata": {}, 271 | "outputs": [], 272 | "source": [ 273 | "import numpy as np" 274 | ] 275 | }, 276 | { 277 | "cell_type": "code", 278 | "execution_count": 12, 279 | "metadata": {}, 280 | "outputs": [ 281 | { 282 | "data": { 283 | "text/plain": [ 284 | "array([[0.64769422, 0.01280197, 0.10332379, 0.32472542, 0.53926875,\n", 285 | " 0.35774078, 0.15711208, 0.91487455, 0.96151735, 0.8574861 ,\n", 286 | " 0.2787421 , 0.97627813, 0.16413232, 0.77497004, 0.93129065],\n", 287 | " [0.87966714, 0.67802113, 0.52240717, 0.00129652, 0.24219206,\n", 288 | " 0.29573666, 0.59375003, 0.9167803 , 0.83977965, 0.57015565,\n", 289 | " 0.49405311, 0.60344976, 0.71880822, 0.42688501, 0.78744598],\n", 290 | " [0.23115814, 0.44284138, 0.559001 , 0.87296734, 0.83385501,\n", 291 | " 0.76287263, 0.18725481, 0.93564721, 0.03235705, 0.06040263,\n", 292 | " 0.36773658, 0.01834783, 0.25708776, 0.25396127, 0.99125592],\n", 293 | " [0.53412026, 0.54795275, 0.4190027 , 0.74076988, 0.52652915,\n", 294 | " 0.77792548, 0.98081671, 0.29226625, 0.76875547, 0.75182905,\n", 295 | " 0.62994052, 0.02348766, 0.33351113, 0.29116542, 0.34284718],\n", 296 | " [0.06004679, 0.3629819 , 0.45489988, 0.59510196, 0.64351631,\n", 297 | " 0.62140415, 0.72591893, 0.04797569, 0.14897765, 0.24530517,\n", 298 | " 0.84443655, 0.33352077, 0.01457049, 0.58208861, 0.66604658],\n", 299 | " [0.88389317, 0.75294579, 0.5758225 , 0.19107437, 0.41112764,\n", 300 | " 0.42847477, 0.21291358, 0.76063809, 0.76406524, 0.27786192,\n", 301 | " 0.11715043, 0.34787207, 0.2108831 , 0.16040715, 0.99051515],\n", 302 | " [0.34036683, 0.20182696, 0.31144307, 0.73699821, 0.01806397,\n", 303 | " 0.74629637, 0.45469551, 0.18806315, 0.10009931, 0.74903824,\n", 304 | " 0.10500258, 0.98127472, 0.65259609, 0.9396197 , 0.94090172],\n", 305 | " [0.78337785, 0.26273543, 0.75047908, 0.42452973, 0.19312705,\n", 306 | " 0.57831509, 0.9718943 , 0.35346302, 0.9332835 , 0.33824571,\n", 307 | " 0.45380113, 0.67271976, 0.30142037, 0.97784579, 0.99325811],\n", 308 | " [0.55218656, 0.67937575, 0.5281673 , 0.23838269, 0.28483763,\n", 309 | " 0.13553149, 0.20499623, 0.97508335, 0.13827528, 0.01108629,\n", 310 | " 0.07578318, 0.57539883, 0.81050646, 0.67958614, 0.95078652],\n", 311 | " [0.6446396 , 0.62516469, 0.86275587, 0.27198486, 0.07693325,\n", 312 | " 0.07361576, 0.91289043, 0.01948493, 0.01705263, 0.8285084 ,\n", 313 | " 0.80085887, 0.50218598, 0.31310783, 0.21245871, 0.16373965],\n", 314 | " [0.34265818, 0.34167176, 0.71314784, 0.23273083, 0.48368295,\n", 315 | " 0.80415759, 0.5212049 , 0.7438377 , 0.68250753, 0.56966597,\n", 316 | " 0.6748693 , 0.40179495, 0.43541608, 0.57560845, 0.09935824],\n", 317 | " [0.46197936, 0.48878296, 0.72942698, 0.41427348, 0.97845704,\n", 318 | " 0.86283648, 0.01356217, 0.79906504, 0.62795523, 0.24777641,\n", 319 | " 0.11024501, 0.35648942, 0.52759138, 0.33766078, 0.89142791],\n", 320 | " [0.66959005, 0.29682607, 0.24899408, 0.32537781, 0.09987803,\n", 321 | " 0.50793979, 0.31885937, 0.52840067, 0.55464389, 0.99363509,\n", 322 | " 0.90831377, 0.59534726, 0.28538442, 0.0442661 , 0.11919888],\n", 323 | " [0.25451728, 0.4838595 , 0.69416996, 0.66129378, 0.04573529,\n", 324 | " 0.06483982, 0.52791652, 0.06952762, 0.85131623, 0.79224382,\n", 325 | " 0.31803633, 0.61042294, 0.91676159, 0.88846294, 0.2410895 ],\n", 326 | " [0.92965514, 0.50466759, 0.75457898, 0.63272708, 0.13474259,\n", 327 | " 0.73958355, 0.90136648, 0.26529961, 0.40699422, 0.39974163,\n", 328 | " 0.29137698, 0.63044698, 0.56595562, 0.07260971, 0.30811679]])" 329 | ] 330 | }, 331 | "execution_count": 12, 332 | "metadata": {}, 333 | "output_type": "execute_result" 334 | } 335 | ], 336 | "source": [ 337 | "m = np.random.rand(15, 15)\n", 338 | "\n", 339 | "m" 340 | ] 341 | }, 342 | { 343 | "cell_type": "code", 344 | "execution_count": 13, 345 | "metadata": {}, 346 | "outputs": [ 347 | { 348 | "data": { 349 | "text/plain": [ 350 | "array([[0.64769422, 0.01280197, 0.10332379, 0.32472542, 0.53926875,\n", 351 | " 0.35774078, 0.15711208, 0.91487455, 0.96151735, 0.8574861 ,\n", 352 | " 0.2787421 , 0.97627813, 0.16413232, 0.77497004, 0.93129065],\n", 353 | " [0.87966714, 0.67802113, 0.52240717, 0.00129652, 0.24219206,\n", 354 | " 0.29573666, 0.59375003, 0.9167803 , 0.83977965, 0.57015565,\n", 355 | " 0.49405311, 0.60344976, 0.71880822, 0.42688501, 0.78744598],\n", 356 | " [0.23115814, 0.44284138, 0.559001 , 0.87296734, 0.83385501,\n", 357 | " 0.76287263, 0.18725481, 0.93564721, 0.03235705, 0.06040263,\n", 358 | " 0.36773658, 0.01834783, 0.25708776, 0.25396127, 0.99125592],\n", 359 | " [0.53412026, 0.54795275, 0.4190027 , 0.74076988, 0.52652915,\n", 360 | " 0.77792548, 0.98081671, 0.29226625, 0.76875547, 0.75182905,\n", 361 | " 0.62994052, 0.02348766, 0.33351113, 0.29116542, 0.34284718],\n", 362 | " [0.06004679, 0.3629819 , 0.45489988, 0.59510196, 0.64351631,\n", 363 | " 0.62140415, 0.72591893, 0.04797569, 0.14897765, 0.24530517,\n", 364 | " 0.84443655, 0.33352077, 0.01457049, 0.58208861, 0.66604658],\n", 365 | " [0.88389317, 0.75294579, 0.5758225 , 0.19107437, 0.41112764,\n", 366 | " 0.42847477, 0.21291358, 0.76063809, 0.76406524, 0.27786192,\n", 367 | " 0.11715043, 0.34787207, 0.2108831 , 0.16040715, 0.99051515],\n", 368 | " [0.34036683, 0.20182696, 0.31144307, 0.73699821, 0.01806397,\n", 369 | " 0.74629637, 0.45469551, 0.18806315, 0.10009931, 0.74903824,\n", 370 | " 0.10500258, 0.98127472, 0.65259609, 0.9396197 , 0.94090172]])" 371 | ] 372 | }, 373 | "execution_count": 13, 374 | "metadata": {}, 375 | "output_type": "execute_result" 376 | } 377 | ], 378 | "source": [ 379 | "m2 = m[0:7, :]\n", 380 | "\n", 381 | "m2" 382 | ] 383 | }, 384 | { 385 | "cell_type": "markdown", 386 | "metadata": {}, 387 | "source": [ 388 | "# Ejercicio 170\n", 389 | "\n", 390 | "Crear una arreglo con 10 elementos y luego aleatorizar sus posiciones." 391 | ] 392 | }, 393 | { 394 | "cell_type": "markdown", 395 | "metadata": {}, 396 | "source": [ 397 | "## Solución:" 398 | ] 399 | }, 400 | { 401 | "cell_type": "code", 402 | "execution_count": 14, 403 | "metadata": {}, 404 | "outputs": [], 405 | "source": [ 406 | "import numpy as np" 407 | ] 408 | }, 409 | { 410 | "cell_type": "code", 411 | "execution_count": 15, 412 | "metadata": {}, 413 | "outputs": [ 414 | { 415 | "data": { 416 | "text/plain": [ 417 | "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" 418 | ] 419 | }, 420 | "execution_count": 15, 421 | "metadata": {}, 422 | "output_type": "execute_result" 423 | } 424 | ], 425 | "source": [ 426 | "a = np.arange(10)\n", 427 | "\n", 428 | "a" 429 | ] 430 | }, 431 | { 432 | "cell_type": "code", 433 | "execution_count": 16, 434 | "metadata": {}, 435 | "outputs": [], 436 | "source": [ 437 | "np.random.shuffle(a)" 438 | ] 439 | }, 440 | { 441 | "cell_type": "code", 442 | "execution_count": 17, 443 | "metadata": {}, 444 | "outputs": [ 445 | { 446 | "data": { 447 | "text/plain": [ 448 | "array([4, 5, 2, 0, 7, 1, 9, 6, 3, 8])" 449 | ] 450 | }, 451 | "execution_count": 17, 452 | "metadata": {}, 453 | "output_type": "execute_result" 454 | } 455 | ], 456 | "source": [ 457 | "a" 458 | ] 459 | }, 460 | { 461 | "cell_type": "code", 462 | "execution_count": 18, 463 | "metadata": {}, 464 | "outputs": [ 465 | { 466 | "data": { 467 | "text/plain": [ 468 | "array([6, 3, 2, 9, 4, 5, 8, 1, 0, 7])" 469 | ] 470 | }, 471 | "execution_count": 18, 472 | "metadata": {}, 473 | "output_type": "execute_result" 474 | } 475 | ], 476 | "source": [ 477 | "np.random.permutation(10)" 478 | ] 479 | }, 480 | { 481 | "cell_type": "markdown", 482 | "metadata": {}, 483 | "source": [ 484 | "# Ejercicio 171\n", 485 | "\n", 486 | "Normalizar una matriz de 5x5." 487 | ] 488 | }, 489 | { 490 | "cell_type": "markdown", 491 | "metadata": {}, 492 | "source": [ 493 | "## Solución:" 494 | ] 495 | }, 496 | { 497 | "cell_type": "code", 498 | "execution_count": 19, 499 | "metadata": {}, 500 | "outputs": [], 501 | "source": [ 502 | "import numpy as np" 503 | ] 504 | }, 505 | { 506 | "cell_type": "code", 507 | "execution_count": 20, 508 | "metadata": {}, 509 | "outputs": [ 510 | { 511 | "data": { 512 | "text/plain": [ 513 | "array([[0.45399668, 0.14205697, 0.88039212, 0.34684498, 0.69620826],\n", 514 | " [0.30232685, 0.54419413, 0.74614654, 0.04591222, 0.12676902],\n", 515 | " [0.07012442, 0.96605491, 0.93108695, 0.18120784, 0.55140124],\n", 516 | " [0.80676556, 0.56427901, 0.08165361, 0.79809306, 0.9800152 ],\n", 517 | " [0.53560022, 0.59802936, 0.15079609, 0.81332161, 0.0995853 ]])" 518 | ] 519 | }, 520 | "execution_count": 20, 521 | "metadata": {}, 522 | "output_type": "execute_result" 523 | } 524 | ], 525 | "source": [ 526 | "m = np.random.random((5, 5))\n", 527 | "\n", 528 | "m" 529 | ] 530 | }, 531 | { 532 | "cell_type": "code", 533 | "execution_count": 21, 534 | "metadata": {}, 535 | "outputs": [ 536 | { 537 | "data": { 538 | "text/plain": [ 539 | "(0.045912217486786866, 0.9800151999399386)" 540 | ] 541 | }, 542 | "execution_count": 21, 543 | "metadata": {}, 544 | "output_type": "execute_result" 545 | } 546 | ], 547 | "source": [ 548 | "minimo = m.min()\n", 549 | "maximo = m.max()\n", 550 | "\n", 551 | "minimo, maximo" 552 | ] 553 | }, 554 | { 555 | "cell_type": "code", 556 | "execution_count": 22, 557 | "metadata": {}, 558 | "outputs": [], 559 | "source": [ 560 | "m = (m - minimo) / (maximo - minimo)" 561 | ] 562 | }, 563 | { 564 | "cell_type": "code", 565 | "execution_count": 23, 566 | "metadata": {}, 567 | "outputs": [ 568 | { 569 | "data": { 570 | "text/plain": [ 571 | "array([[0.4368731 , 0.10292736, 0.89334893, 0.3221623 , 0.69617168],\n", 572 | " [0.2745036 , 0.5334336 , 0.74963289, 0. , 0.08656091],\n", 573 | " [0.02592027, 0.98505487, 0.94762007, 0.14484016, 0.54114914],\n", 574 | " [0.81452833, 0.55493538, 0.0382628 , 0.80524402, 1. ],\n", 575 | " [0.52423342, 0.59106667, 0.11228299, 0.82154689, 0.05745949]])" 576 | ] 577 | }, 578 | "execution_count": 23, 579 | "metadata": {}, 580 | "output_type": "execute_result" 581 | } 582 | ], 583 | "source": [ 584 | "m" 585 | ] 586 | }, 587 | { 588 | "cell_type": "markdown", 589 | "metadata": {}, 590 | "source": [ 591 | "# Ejercicio 172\n", 592 | "\n", 593 | "Generar arreglo con elementos aleatorios y ordernarlo de forma ascendente." 594 | ] 595 | }, 596 | { 597 | "cell_type": "markdown", 598 | "metadata": {}, 599 | "source": [ 600 | "## Solución:" 601 | ] 602 | }, 603 | { 604 | "cell_type": "code", 605 | "execution_count": 24, 606 | "metadata": {}, 607 | "outputs": [], 608 | "source": [ 609 | "import numpy as np" 610 | ] 611 | }, 612 | { 613 | "cell_type": "code", 614 | "execution_count": 25, 615 | "metadata": {}, 616 | "outputs": [ 617 | { 618 | "data": { 619 | "text/plain": [ 620 | "array([0.55146614, 0.17721642, 0.22621309, 0.2797245 , 0.36008521,\n", 621 | " 0.25169087, 0.47399441, 0.31305991, 0.08142928, 0.69657589,\n", 622 | " 0.27351075, 0.67119878, 0.22967499, 0.84229768, 0.20293851])" 623 | ] 624 | }, 625 | "execution_count": 25, 626 | "metadata": {}, 627 | "output_type": "execute_result" 628 | } 629 | ], 630 | "source": [ 631 | "a = np.random.random(15)\n", 632 | "\n", 633 | "a" 634 | ] 635 | }, 636 | { 637 | "cell_type": "code", 638 | "execution_count": 26, 639 | "metadata": {}, 640 | "outputs": [], 641 | "source": [ 642 | "a.sort()" 643 | ] 644 | }, 645 | { 646 | "cell_type": "code", 647 | "execution_count": 27, 648 | "metadata": {}, 649 | "outputs": [ 650 | { 651 | "data": { 652 | "text/plain": [ 653 | "array([0.08142928, 0.17721642, 0.20293851, 0.22621309, 0.22967499,\n", 654 | " 0.25169087, 0.27351075, 0.2797245 , 0.31305991, 0.36008521,\n", 655 | " 0.47399441, 0.55146614, 0.67119878, 0.69657589, 0.84229768])" 656 | ] 657 | }, 658 | "execution_count": 27, 659 | "metadata": {}, 660 | "output_type": "execute_result" 661 | } 662 | ], 663 | "source": [ 664 | "a" 665 | ] 666 | }, 667 | { 668 | "cell_type": "markdown", 669 | "metadata": {}, 670 | "source": [ 671 | "# Ejercicio 173\n", 672 | "\n", 673 | "Encontrar el valor más cercano a un valor arbitrario." 674 | ] 675 | }, 676 | { 677 | "cell_type": "markdown", 678 | "metadata": {}, 679 | "source": [ 680 | "## Solución:" 681 | ] 682 | }, 683 | { 684 | "cell_type": "code", 685 | "execution_count": 28, 686 | "metadata": {}, 687 | "outputs": [], 688 | "source": [ 689 | "import numpy as np" 690 | ] 691 | }, 692 | { 693 | "cell_type": "code", 694 | "execution_count": 29, 695 | "metadata": {}, 696 | "outputs": [ 697 | { 698 | "data": { 699 | "text/plain": [ 700 | "array([ 8.47785611, 10.94464126, 3.98145678, 12.11036863, 1.48666639,\n", 701 | " 5.52092679, 12.75839945, 13.74372606, 18.85691308, 9.88305897])" 702 | ] 703 | }, 704 | "execution_count": 29, 705 | "metadata": {}, 706 | "output_type": "execute_result" 707 | } 708 | ], 709 | "source": [ 710 | "a = np.random.uniform(1, 20, 10)\n", 711 | "\n", 712 | "a" 713 | ] 714 | }, 715 | { 716 | "cell_type": "code", 717 | "execution_count": 30, 718 | "metadata": {}, 719 | "outputs": [], 720 | "source": [ 721 | "valor = 5" 722 | ] 723 | }, 724 | { 725 | "cell_type": "code", 726 | "execution_count": 31, 727 | "metadata": {}, 728 | "outputs": [ 729 | { 730 | "data": { 731 | "text/plain": [ 732 | "5.520926786467988" 733 | ] 734 | }, 735 | "execution_count": 31, 736 | "metadata": {}, 737 | "output_type": "execute_result" 738 | } 739 | ], 740 | "source": [ 741 | "a.flat[np.abs(a - valor).argmin()]" 742 | ] 743 | }, 744 | { 745 | "cell_type": "markdown", 746 | "metadata": {}, 747 | "source": [ 748 | "# Ejercicio 174\n", 749 | "\n", 750 | "Comprobar si dos arreglos aleatorios son iguales." 751 | ] 752 | }, 753 | { 754 | "cell_type": "markdown", 755 | "metadata": {}, 756 | "source": [ 757 | "## Solución:" 758 | ] 759 | }, 760 | { 761 | "cell_type": "code", 762 | "execution_count": 32, 763 | "metadata": {}, 764 | "outputs": [], 765 | "source": [ 766 | "import numpy as np" 767 | ] 768 | }, 769 | { 770 | "cell_type": "code", 771 | "execution_count": 33, 772 | "metadata": {}, 773 | "outputs": [ 774 | { 775 | "data": { 776 | "text/plain": [ 777 | "array([1, 0, 1, 0, 1])" 778 | ] 779 | }, 780 | "execution_count": 33, 781 | "metadata": {}, 782 | "output_type": "execute_result" 783 | } 784 | ], 785 | "source": [ 786 | "a = np.random.randint(0, 2, 5)\n", 787 | "a" 788 | ] 789 | }, 790 | { 791 | "cell_type": "code", 792 | "execution_count": 34, 793 | "metadata": {}, 794 | "outputs": [ 795 | { 796 | "data": { 797 | "text/plain": [ 798 | "array([0, 0, 1, 0, 1])" 799 | ] 800 | }, 801 | "execution_count": 34, 802 | "metadata": {}, 803 | "output_type": "execute_result" 804 | } 805 | ], 806 | "source": [ 807 | "b = np.random.randint(0, 2, 5)\n", 808 | "b" 809 | ] 810 | }, 811 | { 812 | "cell_type": "code", 813 | "execution_count": 35, 814 | "metadata": {}, 815 | "outputs": [ 816 | { 817 | "data": { 818 | "text/plain": [ 819 | "False" 820 | ] 821 | }, 822 | "execution_count": 35, 823 | "metadata": {}, 824 | "output_type": "execute_result" 825 | } 826 | ], 827 | "source": [ 828 | "np.allclose(a, b)" 829 | ] 830 | }, 831 | { 832 | "cell_type": "markdown", 833 | "metadata": {}, 834 | "source": [ 835 | "# Ejercicio 175\n", 836 | "\n", 837 | "Generar un arreglo con valores aleatorios y reemplazar el valor mayor con -1." 838 | ] 839 | }, 840 | { 841 | "cell_type": "markdown", 842 | "metadata": {}, 843 | "source": [ 844 | "## Solución:" 845 | ] 846 | }, 847 | { 848 | "cell_type": "code", 849 | "execution_count": 36, 850 | "metadata": {}, 851 | "outputs": [], 852 | "source": [ 853 | "import numpy as np" 854 | ] 855 | }, 856 | { 857 | "cell_type": "code", 858 | "execution_count": 37, 859 | "metadata": {}, 860 | "outputs": [ 861 | { 862 | "data": { 863 | "text/plain": [ 864 | "array([0.50437848, 0.30733231, 0.87464564, 0.73424977, 0.95561016,\n", 865 | " 0.31682677, 0.5963207 , 0.01177664, 0.03458831, 0.93280109,\n", 866 | " 0.32989026, 0.1190464 , 0.68569338, 0.50855383, 0.69138014,\n", 867 | " 0.76522328, 0.02500786, 0.29230836, 0.97599546, 0.25285782])" 868 | ] 869 | }, 870 | "execution_count": 37, 871 | "metadata": {}, 872 | "output_type": "execute_result" 873 | } 874 | ], 875 | "source": [ 876 | "a = np.random.random(20)\n", 877 | "\n", 878 | "a" 879 | ] 880 | }, 881 | { 882 | "cell_type": "code", 883 | "execution_count": 38, 884 | "metadata": {}, 885 | "outputs": [ 886 | { 887 | "data": { 888 | "text/plain": [ 889 | "0.975995464011742" 890 | ] 891 | }, 892 | "execution_count": 38, 893 | "metadata": {}, 894 | "output_type": "execute_result" 895 | } 896 | ], 897 | "source": [ 898 | "a.max()" 899 | ] 900 | }, 901 | { 902 | "cell_type": "code", 903 | "execution_count": 39, 904 | "metadata": {}, 905 | "outputs": [], 906 | "source": [ 907 | "a[a.argmax()] = -1" 908 | ] 909 | }, 910 | { 911 | "cell_type": "code", 912 | "execution_count": 40, 913 | "metadata": {}, 914 | "outputs": [ 915 | { 916 | "data": { 917 | "text/plain": [ 918 | "array([ 0.50437848, 0.30733231, 0.87464564, 0.73424977, 0.95561016,\n", 919 | " 0.31682677, 0.5963207 , 0.01177664, 0.03458831, 0.93280109,\n", 920 | " 0.32989026, 0.1190464 , 0.68569338, 0.50855383, 0.69138014,\n", 921 | " 0.76522328, 0.02500786, 0.29230836, -1. , 0.25285782])" 922 | ] 923 | }, 924 | "execution_count": 40, 925 | "metadata": {}, 926 | "output_type": "execute_result" 927 | } 928 | ], 929 | "source": [ 930 | "a" 931 | ] 932 | }, 933 | { 934 | "cell_type": "markdown", 935 | "metadata": {}, 936 | "source": [ 937 | "# Ejercicio 176\n", 938 | "\n", 939 | "Encontrar el valor más frecuente en un arreglo." 940 | ] 941 | }, 942 | { 943 | "cell_type": "markdown", 944 | "metadata": {}, 945 | "source": [ 946 | "## Solución:" 947 | ] 948 | }, 949 | { 950 | "cell_type": "code", 951 | "execution_count": 41, 952 | "metadata": {}, 953 | "outputs": [], 954 | "source": [ 955 | "import numpy as np" 956 | ] 957 | }, 958 | { 959 | "cell_type": "code", 960 | "execution_count": 42, 961 | "metadata": {}, 962 | "outputs": [ 963 | { 964 | "data": { 965 | "text/plain": [ 966 | "array([13, 1, 10, 2, 12, 5, 1, 14, 13, 1, 12, 6, 10, 12, 7, 14, 13,\n", 967 | " 2, 14, 0])" 968 | ] 969 | }, 970 | "execution_count": 42, 971 | "metadata": {}, 972 | "output_type": "execute_result" 973 | } 974 | ], 975 | "source": [ 976 | "a = np.random.randint(0, 15, 20)\n", 977 | "\n", 978 | "a" 979 | ] 980 | }, 981 | { 982 | "cell_type": "code", 983 | "execution_count": 43, 984 | "metadata": {}, 985 | "outputs": [ 986 | { 987 | "data": { 988 | "text/plain": [ 989 | "1" 990 | ] 991 | }, 992 | "execution_count": 43, 993 | "metadata": {}, 994 | "output_type": "execute_result" 995 | } 996 | ], 997 | "source": [ 998 | "np.bincount(a).argmax()" 999 | ] 1000 | }, 1001 | { 1002 | "cell_type": "markdown", 1003 | "metadata": {}, 1004 | "source": [ 1005 | "# Ejercicio 177\n", 1006 | "\n", 1007 | "A partir de una matriz con coordenadas cartesianas realizar la conversión a coordendas polares." 1008 | ] 1009 | }, 1010 | { 1011 | "cell_type": "markdown", 1012 | "metadata": {}, 1013 | "source": [ 1014 | "## Solución:" 1015 | ] 1016 | }, 1017 | { 1018 | "cell_type": "code", 1019 | "execution_count": 44, 1020 | "metadata": {}, 1021 | "outputs": [], 1022 | "source": [ 1023 | "import numpy as np" 1024 | ] 1025 | }, 1026 | { 1027 | "cell_type": "code", 1028 | "execution_count": 45, 1029 | "metadata": {}, 1030 | "outputs": [ 1031 | { 1032 | "data": { 1033 | "text/plain": [ 1034 | "array([0.41041381, 0.03411976, 0.48700534, 0.43749638, 0.9339806 ,\n", 1035 | " 0.09443086, 0.36996966, 0.39159732, 0.03181983, 0.39569267,\n", 1036 | " 0.19028769, 0.34245803, 0.5873676 , 0.38191875, 0.24055526])" 1037 | ] 1038 | }, 1039 | "execution_count": 45, 1040 | "metadata": {}, 1041 | "output_type": "execute_result" 1042 | } 1043 | ], 1044 | "source": [ 1045 | "m = np.random.random((15, 2))\n", 1046 | "\n", 1047 | "x = m[:,0]\n", 1048 | "y = m[:,1]\n", 1049 | "\n", 1050 | "x" 1051 | ] 1052 | }, 1053 | { 1054 | "cell_type": "code", 1055 | "execution_count": 46, 1056 | "metadata": {}, 1057 | "outputs": [ 1058 | { 1059 | "data": { 1060 | "text/plain": [ 1061 | "array([0.90913607, 0.35696928, 0.32965596, 0.53597949, 0.27502437,\n", 1062 | " 0.96376522, 0.89584455, 0.03760622, 0.01800424, 0.61130039,\n", 1063 | " 0.50310067, 0.66712238, 0.12477475, 0.60794484, 0.03090979])" 1064 | ] 1065 | }, 1066 | "execution_count": 46, 1067 | "metadata": {}, 1068 | "output_type": "execute_result" 1069 | } 1070 | ], 1071 | "source": [ 1072 | "y" 1073 | ] 1074 | }, 1075 | { 1076 | "cell_type": "code", 1077 | "execution_count": 47, 1078 | "metadata": {}, 1079 | "outputs": [ 1080 | { 1081 | "data": { 1082 | "text/plain": [ 1083 | "array([0.99748077, 0.35859619, 0.58808779, 0.69186494, 0.97363143,\n", 1084 | " 0.9683804 , 0.96923424, 0.3933989 , 0.03656028, 0.72819012,\n", 1085 | " 0.53788445, 0.74988651, 0.60047434, 0.71795463, 0.24253299])" 1086 | ] 1087 | }, 1088 | "execution_count": 47, 1089 | "metadata": {}, 1090 | "output_type": "execute_result" 1091 | } 1092 | ], 1093 | "source": [ 1094 | "r = np.sqrt(x**2 + y**2)\n", 1095 | "\n", 1096 | "r" 1097 | ] 1098 | }, 1099 | { 1100 | "cell_type": "code", 1101 | "execution_count": 48, 1102 | "metadata": {}, 1103 | "outputs": [ 1104 | { 1105 | "data": { 1106 | "text/plain": [ 1107 | "array([1.14675156, 1.47550404, 0.59505668, 0.88622159, 0.28637088,\n", 1108 | " 1.4731269 , 1.17914701, 0.09573928, 0.51490645, 0.9963239 ,\n", 1109 | " 1.20919702, 1.09653681, 0.20931882, 1.00989 , 0.12779327])" 1110 | ] 1111 | }, 1112 | "execution_count": 48, 1113 | "metadata": {}, 1114 | "output_type": "execute_result" 1115 | } 1116 | ], 1117 | "source": [ 1118 | "t = np.arctan2(y, x)\n", 1119 | "\n", 1120 | "t" 1121 | ] 1122 | }, 1123 | { 1124 | "cell_type": "markdown", 1125 | "metadata": {}, 1126 | "source": [ 1127 | "# Ejercicio 178\n", 1128 | "\n", 1129 | "Obtener los `n` números mayores en un arreglo." 1130 | ] 1131 | }, 1132 | { 1133 | "cell_type": "markdown", 1134 | "metadata": {}, 1135 | "source": [ 1136 | "## Solución:" 1137 | ] 1138 | }, 1139 | { 1140 | "cell_type": "code", 1141 | "execution_count": 49, 1142 | "metadata": {}, 1143 | "outputs": [], 1144 | "source": [ 1145 | "import numpy as np" 1146 | ] 1147 | }, 1148 | { 1149 | "cell_type": "code", 1150 | "execution_count": 50, 1151 | "metadata": {}, 1152 | "outputs": [ 1153 | { 1154 | "data": { 1155 | "text/plain": [ 1156 | "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])" 1157 | ] 1158 | }, 1159 | "execution_count": 50, 1160 | "metadata": {}, 1161 | "output_type": "execute_result" 1162 | } 1163 | ], 1164 | "source": [ 1165 | "a = np.arange(15)\n", 1166 | "\n", 1167 | "a" 1168 | ] 1169 | }, 1170 | { 1171 | "cell_type": "code", 1172 | "execution_count": 51, 1173 | "metadata": {}, 1174 | "outputs": [ 1175 | { 1176 | "data": { 1177 | "text/plain": [ 1178 | "array([ 0, 12, 14, 10, 7, 1, 4, 5, 13, 11, 6, 3, 9, 2, 8])" 1179 | ] 1180 | }, 1181 | "execution_count": 51, 1182 | "metadata": {}, 1183 | "output_type": "execute_result" 1184 | } 1185 | ], 1186 | "source": [ 1187 | "np.random.shuffle(a)\n", 1188 | "\n", 1189 | "a" 1190 | ] 1191 | }, 1192 | { 1193 | "cell_type": "code", 1194 | "execution_count": 52, 1195 | "metadata": {}, 1196 | "outputs": [], 1197 | "source": [ 1198 | "n = 3" 1199 | ] 1200 | }, 1201 | { 1202 | "cell_type": "code", 1203 | "execution_count": 53, 1204 | "metadata": {}, 1205 | "outputs": [ 1206 | { 1207 | "data": { 1208 | "text/plain": [ 1209 | "array([12, 13, 14])" 1210 | ] 1211 | }, 1212 | "execution_count": 53, 1213 | "metadata": {}, 1214 | "output_type": "execute_result" 1215 | } 1216 | ], 1217 | "source": [ 1218 | "a[np.argsort(a)[-n:]]" 1219 | ] 1220 | }, 1221 | { 1222 | "cell_type": "markdown", 1223 | "metadata": {}, 1224 | "source": [ 1225 | "# Ejercicio 179\n", 1226 | "\n", 1227 | "Ordenar una matriz por diferentes ejes, y por la versión arreglo de sus elementos." 1228 | ] 1229 | }, 1230 | { 1231 | "cell_type": "markdown", 1232 | "metadata": {}, 1233 | "source": [ 1234 | "## Solución:" 1235 | ] 1236 | }, 1237 | { 1238 | "cell_type": "code", 1239 | "execution_count": 54, 1240 | "metadata": {}, 1241 | "outputs": [], 1242 | "source": [ 1243 | "import numpy as np" 1244 | ] 1245 | }, 1246 | { 1247 | "cell_type": "code", 1248 | "execution_count": 55, 1249 | "metadata": {}, 1250 | "outputs": [ 1251 | { 1252 | "data": { 1253 | "text/plain": [ 1254 | "array([[3, 2, 1],\n", 1255 | " [8, 4, 3],\n", 1256 | " [5, 6, 0]])" 1257 | ] 1258 | }, 1259 | "execution_count": 55, 1260 | "metadata": {}, 1261 | "output_type": "execute_result" 1262 | } 1263 | ], 1264 | "source": [ 1265 | "m = np.array([[3, 2, 1], [8, 4, 3], [5, 6, 0]])\n", 1266 | "\n", 1267 | "m" 1268 | ] 1269 | }, 1270 | { 1271 | "cell_type": "code", 1272 | "execution_count": 56, 1273 | "metadata": {}, 1274 | "outputs": [ 1275 | { 1276 | "data": { 1277 | "text/plain": [ 1278 | "array([[3, 2, 0],\n", 1279 | " [5, 4, 1],\n", 1280 | " [8, 6, 3]])" 1281 | ] 1282 | }, 1283 | "execution_count": 56, 1284 | "metadata": {}, 1285 | "output_type": "execute_result" 1286 | } 1287 | ], 1288 | "source": [ 1289 | "np.sort(m, axis=0)" 1290 | ] 1291 | }, 1292 | { 1293 | "cell_type": "code", 1294 | "execution_count": 57, 1295 | "metadata": {}, 1296 | "outputs": [ 1297 | { 1298 | "data": { 1299 | "text/plain": [ 1300 | "array([[1, 2, 3],\n", 1301 | " [3, 4, 8],\n", 1302 | " [0, 5, 6]])" 1303 | ] 1304 | }, 1305 | "execution_count": 57, 1306 | "metadata": {}, 1307 | "output_type": "execute_result" 1308 | } 1309 | ], 1310 | "source": [ 1311 | "np.sort(m)" 1312 | ] 1313 | }, 1314 | { 1315 | "cell_type": "code", 1316 | "execution_count": 58, 1317 | "metadata": {}, 1318 | "outputs": [ 1319 | { 1320 | "data": { 1321 | "text/plain": [ 1322 | "array([0, 1, 2, 3, 3, 4, 5, 6, 8])" 1323 | ] 1324 | }, 1325 | "execution_count": 58, 1326 | "metadata": {}, 1327 | "output_type": "execute_result" 1328 | } 1329 | ], 1330 | "source": [ 1331 | "np.sort(m, axis=None)" 1332 | ] 1333 | }, 1334 | { 1335 | "cell_type": "markdown", 1336 | "metadata": {}, 1337 | "source": [ 1338 | "# Ejercicio 180\n", 1339 | "\n", 1340 | "Crear un arreglo con elementos definidos a partir de una estructura arbitraria." 1341 | ] 1342 | }, 1343 | { 1344 | "cell_type": "markdown", 1345 | "metadata": {}, 1346 | "source": [ 1347 | "## Solución:" 1348 | ] 1349 | }, 1350 | { 1351 | "cell_type": "code", 1352 | "execution_count": 59, 1353 | "metadata": {}, 1354 | "outputs": [], 1355 | "source": [ 1356 | "import numpy as np" 1357 | ] 1358 | }, 1359 | { 1360 | "cell_type": "code", 1361 | "execution_count": 60, 1362 | "metadata": {}, 1363 | "outputs": [], 1364 | "source": [ 1365 | "estudiante = [('nombre', 'S15'), ('curso', int), ('nota', float)]" 1366 | ] 1367 | }, 1368 | { 1369 | "cell_type": "code", 1370 | "execution_count": 61, 1371 | "metadata": {}, 1372 | "outputs": [ 1373 | { 1374 | "data": { 1375 | "text/plain": [ 1376 | "[('Edward', 1, 4.5), ('German', 2, 4.3), ('Paula', 1, 4.1)]" 1377 | ] 1378 | }, 1379 | "execution_count": 61, 1380 | "metadata": {}, 1381 | "output_type": "execute_result" 1382 | } 1383 | ], 1384 | "source": [ 1385 | "estudiantes = [('Edward', 1, 4.5), ('German', 2, 4.3), ('Paula', 1, 4.1)]\n", 1386 | "estudiantes" 1387 | ] 1388 | }, 1389 | { 1390 | "cell_type": "code", 1391 | "execution_count": 62, 1392 | "metadata": {}, 1393 | "outputs": [], 1394 | "source": [ 1395 | "arrEstudiantes = np.array(estudiantes, dtype=estudiante)" 1396 | ] 1397 | }, 1398 | { 1399 | "cell_type": "code", 1400 | "execution_count": 63, 1401 | "metadata": {}, 1402 | "outputs": [ 1403 | { 1404 | "data": { 1405 | "text/plain": [ 1406 | "array([(b'Edward', 1, 4.5), (b'German', 2, 4.3), (b'Paula', 1, 4.1)],\n", 1407 | " dtype=[('nombre', 'S15'), ('curso', '\n", 1345 | "b) $15x^{2}+20x+25$" 1346 | ] 1347 | }, 1348 | { 1349 | "cell_type": "markdown", 1350 | "metadata": {}, 1351 | "source": [ 1352 | "## Solución:" 1353 | ] 1354 | }, 1355 | { 1356 | "cell_type": "code", 1357 | "execution_count": 62, 1358 | "metadata": {}, 1359 | "outputs": [], 1360 | "source": [ 1361 | "import numpy as np\n", 1362 | "\n", 1363 | "coef_a = (5, 10, 15)\n", 1364 | "coef_b = (15, 20, 25)" 1365 | ] 1366 | }, 1367 | { 1368 | "cell_type": "code", 1369 | "execution_count": 63, 1370 | "metadata": {}, 1371 | "outputs": [ 1372 | { 1373 | "data": { 1374 | "text/plain": [ 1375 | "array([20., 30., 40.])" 1376 | ] 1377 | }, 1378 | "execution_count": 63, 1379 | "metadata": {}, 1380 | "output_type": "execute_result" 1381 | } 1382 | ], 1383 | "source": [ 1384 | "np.polynomial.polynomial.polyadd(coef_a, coef_b)" 1385 | ] 1386 | }, 1387 | { 1388 | "cell_type": "code", 1389 | "execution_count": 64, 1390 | "metadata": {}, 1391 | "outputs": [ 1392 | { 1393 | "data": { 1394 | "text/plain": [ 1395 | "array([-10., -10., -10.])" 1396 | ] 1397 | }, 1398 | "execution_count": 64, 1399 | "metadata": {}, 1400 | "output_type": "execute_result" 1401 | } 1402 | ], 1403 | "source": [ 1404 | "np.polynomial.polynomial.polysub(coef_a, coef_b)" 1405 | ] 1406 | }, 1407 | { 1408 | "cell_type": "code", 1409 | "execution_count": 65, 1410 | "metadata": {}, 1411 | "outputs": [ 1412 | { 1413 | "data": { 1414 | "text/plain": [ 1415 | "array([ 75., 250., 550., 550., 375.])" 1416 | ] 1417 | }, 1418 | "execution_count": 65, 1419 | "metadata": {}, 1420 | "output_type": "execute_result" 1421 | } 1422 | ], 1423 | "source": [ 1424 | "np.polynomial.polynomial.polymul(coef_a, coef_b)" 1425 | ] 1426 | }, 1427 | { 1428 | "cell_type": "code", 1429 | "execution_count": 66, 1430 | "metadata": {}, 1431 | "outputs": [ 1432 | { 1433 | "data": { 1434 | "text/plain": [ 1435 | "(array([0.6]), array([-4., -2.]))" 1436 | ] 1437 | }, 1438 | "execution_count": 66, 1439 | "metadata": {}, 1440 | "output_type": "execute_result" 1441 | } 1442 | ], 1443 | "source": [ 1444 | "np.polynomial.polynomial.polydiv(coef_a, coef_b)" 1445 | ] 1446 | }, 1447 | { 1448 | "cell_type": "markdown", 1449 | "metadata": {}, 1450 | "source": [ 1451 | "# Ejercicio 59\n", 1452 | "\n", 1453 | "Calcular el promedio de una matriz por cada dimensión." 1454 | ] 1455 | }, 1456 | { 1457 | "cell_type": "markdown", 1458 | "metadata": {}, 1459 | "source": [ 1460 | "## Solución:" 1461 | ] 1462 | }, 1463 | { 1464 | "cell_type": "code", 1465 | "execution_count": 67, 1466 | "metadata": {}, 1467 | "outputs": [], 1468 | "source": [ 1469 | "import numpy as np" 1470 | ] 1471 | }, 1472 | { 1473 | "cell_type": "code", 1474 | "execution_count": 68, 1475 | "metadata": {}, 1476 | "outputs": [ 1477 | { 1478 | "data": { 1479 | "text/plain": [ 1480 | "array([[ 5, 10],\n", 1481 | " [12, 24]])" 1482 | ] 1483 | }, 1484 | "execution_count": 68, 1485 | "metadata": {}, 1486 | "output_type": "execute_result" 1487 | } 1488 | ], 1489 | "source": [ 1490 | "matriz = np.array([[5, 10], [12, 24]])\n", 1491 | "matriz" 1492 | ] 1493 | }, 1494 | { 1495 | "cell_type": "code", 1496 | "execution_count": 69, 1497 | "metadata": {}, 1498 | "outputs": [ 1499 | { 1500 | "data": { 1501 | "text/plain": [ 1502 | "array([ 8.5, 17. ])" 1503 | ] 1504 | }, 1505 | "execution_count": 69, 1506 | "metadata": {}, 1507 | "output_type": "execute_result" 1508 | } 1509 | ], 1510 | "source": [ 1511 | "matriz.mean(axis=0)" 1512 | ] 1513 | }, 1514 | { 1515 | "cell_type": "code", 1516 | "execution_count": 70, 1517 | "metadata": {}, 1518 | "outputs": [ 1519 | { 1520 | "data": { 1521 | "text/plain": [ 1522 | "array([ 7.5, 18. ])" 1523 | ] 1524 | }, 1525 | "execution_count": 70, 1526 | "metadata": {}, 1527 | "output_type": "execute_result" 1528 | } 1529 | ], 1530 | "source": [ 1531 | "matriz.mean(axis=1)" 1532 | ] 1533 | }, 1534 | { 1535 | "cell_type": "markdown", 1536 | "metadata": {}, 1537 | "source": [ 1538 | "# Ejercicio 60\n", 1539 | "\n", 1540 | "Calcular estadísticas elementales sobre un arreglo." 1541 | ] 1542 | }, 1543 | { 1544 | "cell_type": "markdown", 1545 | "metadata": {}, 1546 | "source": [ 1547 | "## Solución:" 1548 | ] 1549 | }, 1550 | { 1551 | "cell_type": "code", 1552 | "execution_count": 71, 1553 | "metadata": {}, 1554 | "outputs": [], 1555 | "source": [ 1556 | "import numpy as np" 1557 | ] 1558 | }, 1559 | { 1560 | "cell_type": "code", 1561 | "execution_count": 72, 1562 | "metadata": {}, 1563 | "outputs": [ 1564 | { 1565 | "data": { 1566 | "text/plain": [ 1567 | "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", 1568 | " 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n", 1569 | " 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49])" 1570 | ] 1571 | }, 1572 | "execution_count": 72, 1573 | "metadata": {}, 1574 | "output_type": "execute_result" 1575 | } 1576 | ], 1577 | "source": [ 1578 | "a = np.arange(50)\n", 1579 | "a" 1580 | ] 1581 | }, 1582 | { 1583 | "cell_type": "code", 1584 | "execution_count": 73, 1585 | "metadata": {}, 1586 | "outputs": [ 1587 | { 1588 | "data": { 1589 | "text/plain": [ 1590 | "24.5" 1591 | ] 1592 | }, 1593 | "execution_count": 73, 1594 | "metadata": {}, 1595 | "output_type": "execute_result" 1596 | } 1597 | ], 1598 | "source": [ 1599 | "a.mean()" 1600 | ] 1601 | }, 1602 | { 1603 | "cell_type": "code", 1604 | "execution_count": 74, 1605 | "metadata": {}, 1606 | "outputs": [ 1607 | { 1608 | "data": { 1609 | "text/plain": [ 1610 | "14.430869689661812" 1611 | ] 1612 | }, 1613 | "execution_count": 74, 1614 | "metadata": {}, 1615 | "output_type": "execute_result" 1616 | } 1617 | ], 1618 | "source": [ 1619 | "a.std()" 1620 | ] 1621 | }, 1622 | { 1623 | "cell_type": "code", 1624 | "execution_count": 75, 1625 | "metadata": {}, 1626 | "outputs": [ 1627 | { 1628 | "data": { 1629 | "text/plain": [ 1630 | "208.25" 1631 | ] 1632 | }, 1633 | "execution_count": 75, 1634 | "metadata": {}, 1635 | "output_type": "execute_result" 1636 | } 1637 | ], 1638 | "source": [ 1639 | "a.var()" 1640 | ] 1641 | }, 1642 | { 1643 | "cell_type": "markdown", 1644 | "metadata": {}, 1645 | "source": [ 1646 | "# Ejercicio 61\n", 1647 | "\n", 1648 | "Calcular el seno, coseno y tangente de un arreglo (valores en radianes)." 1649 | ] 1650 | }, 1651 | { 1652 | "cell_type": "markdown", 1653 | "metadata": {}, 1654 | "source": [ 1655 | "## Solución:" 1656 | ] 1657 | }, 1658 | { 1659 | "cell_type": "code", 1660 | "execution_count": 76, 1661 | "metadata": {}, 1662 | "outputs": [], 1663 | "source": [ 1664 | "import numpy as np" 1665 | ] 1666 | }, 1667 | { 1668 | "cell_type": "code", 1669 | "execution_count": 77, 1670 | "metadata": {}, 1671 | "outputs": [], 1672 | "source": [ 1673 | "radianes = [np.pi/6, np.pi/4, np.pi/3, np.pi/2]" 1674 | ] 1675 | }, 1676 | { 1677 | "cell_type": "code", 1678 | "execution_count": 78, 1679 | "metadata": {}, 1680 | "outputs": [ 1681 | { 1682 | "data": { 1683 | "text/plain": [ 1684 | "array([0.5 , 0.70710678, 0.8660254 , 1. ])" 1685 | ] 1686 | }, 1687 | "execution_count": 78, 1688 | "metadata": {}, 1689 | "output_type": "execute_result" 1690 | } 1691 | ], 1692 | "source": [ 1693 | "np.sin(radianes)" 1694 | ] 1695 | }, 1696 | { 1697 | "cell_type": "code", 1698 | "execution_count": 79, 1699 | "metadata": {}, 1700 | "outputs": [ 1701 | { 1702 | "data": { 1703 | "text/plain": [ 1704 | "array([8.66025404e-01, 7.07106781e-01, 5.00000000e-01, 6.12323400e-17])" 1705 | ] 1706 | }, 1707 | "execution_count": 79, 1708 | "metadata": {}, 1709 | "output_type": "execute_result" 1710 | } 1711 | ], 1712 | "source": [ 1713 | "np.cos(radianes)" 1714 | ] 1715 | }, 1716 | { 1717 | "cell_type": "code", 1718 | "execution_count": 80, 1719 | "metadata": {}, 1720 | "outputs": [ 1721 | { 1722 | "data": { 1723 | "text/plain": [ 1724 | "array([5.77350269e-01, 1.00000000e+00, 1.73205081e+00, 1.63312394e+16])" 1725 | ] 1726 | }, 1727 | "execution_count": 80, 1728 | "metadata": {}, 1729 | "output_type": "execute_result" 1730 | } 1731 | ], 1732 | "source": [ 1733 | "np.tan(radianes)" 1734 | ] 1735 | } 1736 | ], 1737 | "metadata": { 1738 | "kernelspec": { 1739 | "display_name": "Python 3", 1740 | "language": "python", 1741 | "name": "python3" 1742 | }, 1743 | "language_info": { 1744 | "codemirror_mode": { 1745 | "name": "ipython", 1746 | "version": 3 1747 | }, 1748 | "file_extension": ".py", 1749 | "mimetype": "text/x-python", 1750 | "name": "python", 1751 | "nbconvert_exporter": "python", 1752 | "pygments_lexer": "ipython3", 1753 | "version": "3.7.1" 1754 | } 1755 | }, 1756 | "nbformat": 4, 1757 | "nbformat_minor": 2 1758 | } 1759 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # NumPy - Ejercicios 2 | 3 | Series de ejercicios de la librería Numpy para el lenguaje de programación Python. 4 | -------------------------------------------------------------------------------- /ejercicio35.npy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Fhernd/Numpy_Ejercicios/3e6dad8bb3529e3cb1f703d249c3151937c763e1/ejercicio35.npy -------------------------------------------------------------------------------- /ejercicio36.npz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Fhernd/Numpy_Ejercicios/3e6dad8bb3529e3cb1f703d249c3151937c763e1/ejercicio36.npz -------------------------------------------------------------------------------- /ejercicio37.txt: -------------------------------------------------------------------------------- 1 | # col1 col2 col3 col4 2 | 0 1 2 3 3 | 4 5 6 7 4 | 8 9 10 11 5 | --------------------------------------------------------------------------------