├── 00.Jupyter_notebooks.ipynb ├── 01.Getting_started.ipynb ├── 02.Strings.ipynb ├── 03.Data_structures.ipynb ├── 04.Loops.ipynb ├── 05.Conditionals.ipynb ├── 06.Functions.ipynb ├── 07.Packages.ipynb ├── 08.Plotting.ipynb ├── 09.Julia_is_fast.ipynb ├── 10.Multiple_dispatch.ipynb ├── 11.Basic_linear_algebra.ipynb ├── 12.Factorizations_and_other_fun.ipynb ├── Exercise_solutions.ipynb ├── Getting to know Julia (quickly).ipynb ├── LICENSE.md ├── es ├── 1. Calentando motores.ipynb ├── 2. Cadenas.ipynb ├── 3. Estructuras de datos.ipynb ├── 4. Bucles.ipynb ├── 5. Condicionales.ipynb ├── 6. Funciones.ipynb ├── 7. Paquetes.ipynb ├── 8. Graficas.ipynb ├── 9. Despacho multiple.ipynb ├── 10. Algebra lineal basica.ipynb ├── 11.Factorizaciones y otras diversiones.ipynb ├── 12. Julia es rapido.ipynb └── Soluciones a ejercicios.ipynb └── pt ├── 00.Notebooks_jupyter.ipynb ├── 01.Comecando_com_Julia.ipynb ├── 02.Strings.ipynb ├── 03.Estrutura_de_dados.ipynb ├── 04.Loops.ipynb ├── 05.Condicionais.ipynb ├── 06.Funcoes.ipynb ├── 07.Pacotes.ipynb ├── 08.Plotando_graficos.ipynb ├── 09.Julia_e_rapido.ipynb ├── 10.Multi_metodos.ipynb ├── 11.Algebra_linear_basica.ipynb ├── 12.Fatorizacoes_e_outras_brincadeiras.ipynb └── Tornando_se_familiar_com_julia_rapidamente.ipynb /00.Jupyter_notebooks.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Getting started with Jupyter notebooks\n", 8 | "\n", 9 | "### Running a cell\n", 10 | "To execute code within a cell, select that cell and either (1) hit `Shift` and `Enter` or (2) hit the run button (the right pointing arrow) above." 11 | ] 12 | }, 13 | { 14 | "cell_type": "code", 15 | "execution_count": null, 16 | "metadata": {}, 17 | "outputs": [], 18 | "source": [ 19 | "1 + 1\n", 20 | "2 + 2" 21 | ] 22 | }, 23 | { 24 | "cell_type": "markdown", 25 | "metadata": {}, 26 | "source": [ 27 | "If you're new to jupyter notebooks, note that only the last line of a cell prints by default when you execute that cell and that you can suppress this output with a semicolon" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": null, 33 | "metadata": {}, 34 | "outputs": [], 35 | "source": [ 36 | "1 + 1\n", 37 | "2 + 2;" 38 | ] 39 | }, 40 | { 41 | "cell_type": "markdown", 42 | "metadata": {}, 43 | "source": [ 44 | "### How to get docs for Julia functions\n", 45 | "\n", 46 | "To get docs for a function you're not familiar with, precede it with a question mark. (This works at the REPL too!)" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": null, 52 | "metadata": {}, 53 | "outputs": [], 54 | "source": [ 55 | "?println" 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "### How to use shell commands\n", 63 | "\n", 64 | "Type `;` and then you can use shell commands. For example," 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": null, 70 | "metadata": {}, 71 | "outputs": [], 72 | "source": [ 73 | ";ls" 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": null, 79 | "metadata": {}, 80 | "outputs": [], 81 | "source": [ 82 | ";pwd" 83 | ] 84 | }, 85 | { 86 | "cell_type": "markdown", 87 | "metadata": { 88 | "collapsed": true 89 | }, 90 | "source": [ 91 | "Shell commands also work at the REPL!" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": null, 97 | "metadata": {}, 98 | "outputs": [], 99 | "source": [] 100 | } 101 | ], 102 | "metadata": { 103 | "kernelspec": { 104 | "display_name": "Julia 1.0.0", 105 | "language": "julia", 106 | "name": "julia-1.0" 107 | }, 108 | "language_info": { 109 | "file_extension": ".jl", 110 | "mimetype": "application/julia", 111 | "name": "julia", 112 | "version": "1.0.1" 113 | } 114 | }, 115 | "nbformat": 4, 116 | "nbformat_minor": 2 117 | } 118 | -------------------------------------------------------------------------------- /01.Getting_started.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Getting started\n", 8 | "\n", 9 | "Topics:\n", 10 | "1. How to print\n", 11 | "2. How to assign variables\n", 12 | "3. How to comment\n", 13 | "4. Syntax for basic math" 14 | ] 15 | }, 16 | { 17 | "cell_type": "markdown", 18 | "metadata": {}, 19 | "source": [ 20 | "## How to print\n", 21 | "\n", 22 | "In Julia we usually use `println()` to print" 23 | ] 24 | }, 25 | { 26 | "cell_type": "code", 27 | "execution_count": null, 28 | "metadata": {}, 29 | "outputs": [], 30 | "source": [ 31 | "println(\"I'm excited to learn Julia!\")" 32 | ] 33 | }, 34 | { 35 | "cell_type": "markdown", 36 | "metadata": {}, 37 | "source": [ 38 | "## How to assign variables\n", 39 | "\n", 40 | "All we need is a variable name, value, and an equal's sign!
\n", 41 | "Julia will figure out types for us." 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": null, 47 | "metadata": {}, 48 | "outputs": [], 49 | "source": [ 50 | "my_answer = 42\n", 51 | "typeof(my_answer)" 52 | ] 53 | }, 54 | { 55 | "cell_type": "code", 56 | "execution_count": null, 57 | "metadata": {}, 58 | "outputs": [], 59 | "source": [ 60 | "my_pi = 3.14159\n", 61 | "typeof(my_pi)" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": null, 67 | "metadata": {}, 68 | "outputs": [], 69 | "source": [ 70 | "😺 = \"smiley cat!\"\n", 71 | "typeof(😺)" 72 | ] 73 | }, 74 | { 75 | "cell_type": "markdown", 76 | "metadata": {}, 77 | "source": [ 78 | "To type a smiley cat, use tab completion to select the emoji name and then tab again" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": null, 84 | "metadata": {}, 85 | "outputs": [], 86 | "source": [ 87 | "# \\:smi + --> select with down arrow + ---> + to complete" 88 | ] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "metadata": {}, 93 | "source": [ 94 | "After assigning a value to a variable, we can reassign a value of a different type to that variable without any issue." 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": null, 100 | "metadata": {}, 101 | "outputs": [], 102 | "source": [ 103 | "😺 = 1" 104 | ] 105 | }, 106 | { 107 | "cell_type": "code", 108 | "execution_count": null, 109 | "metadata": {}, 110 | "outputs": [], 111 | "source": [ 112 | "typeof(😺)" 113 | ] 114 | }, 115 | { 116 | "cell_type": "markdown", 117 | "metadata": {}, 118 | "source": [ 119 | "Note: Julia allows us to write super generic code, and 😺 is an example of this. \n", 120 | "\n", 121 | "This allows us to write code like" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": null, 127 | "metadata": {}, 128 | "outputs": [], 129 | "source": [ 130 | "😀 = 0\n", 131 | "😞 = -1" 132 | ] 133 | }, 134 | { 135 | "cell_type": "code", 136 | "execution_count": null, 137 | "metadata": {}, 138 | "outputs": [], 139 | "source": [ 140 | "😺 + 😞 == 😀" 141 | ] 142 | }, 143 | { 144 | "cell_type": "markdown", 145 | "metadata": {}, 146 | "source": [ 147 | "## How to comment" 148 | ] 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": null, 153 | "metadata": {}, 154 | "outputs": [], 155 | "source": [ 156 | "# You can leave comments on a single line using the pound/hash key" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": null, 162 | "metadata": {}, 163 | "outputs": [], 164 | "source": [ 165 | "#=\n", 166 | "\n", 167 | "For multi-line comments, \n", 168 | "use the '#= =#' sequence.\n", 169 | "\n", 170 | "=#" 171 | ] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "metadata": {}, 176 | "source": [ 177 | "## Syntax for basic math" 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": null, 183 | "metadata": {}, 184 | "outputs": [], 185 | "source": [ 186 | "sum = 3 + 7" 187 | ] 188 | }, 189 | { 190 | "cell_type": "code", 191 | "execution_count": null, 192 | "metadata": {}, 193 | "outputs": [], 194 | "source": [ 195 | "difference = 10 - 3" 196 | ] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": null, 201 | "metadata": {}, 202 | "outputs": [], 203 | "source": [ 204 | "product = 20 * 5" 205 | ] 206 | }, 207 | { 208 | "cell_type": "code", 209 | "execution_count": null, 210 | "metadata": {}, 211 | "outputs": [], 212 | "source": [ 213 | "quotient = 100 / 10" 214 | ] 215 | }, 216 | { 217 | "cell_type": "code", 218 | "execution_count": null, 219 | "metadata": {}, 220 | "outputs": [], 221 | "source": [ 222 | "power = 10 ^ 2" 223 | ] 224 | }, 225 | { 226 | "cell_type": "code", 227 | "execution_count": null, 228 | "metadata": {}, 229 | "outputs": [], 230 | "source": [ 231 | "modulus = 101 % 2" 232 | ] 233 | }, 234 | { 235 | "cell_type": "markdown", 236 | "metadata": {}, 237 | "source": [ 238 | "### Exercises\n", 239 | "\n", 240 | "#### 1.1 \n", 241 | "Look up docs for the `convert` function." 242 | ] 243 | }, 244 | { 245 | "cell_type": "code", 246 | "execution_count": null, 247 | "metadata": {}, 248 | "outputs": [], 249 | "source": [] 250 | }, 251 | { 252 | "cell_type": "markdown", 253 | "metadata": {}, 254 | "source": [ 255 | "#### 1.2 \n", 256 | "Assign `365` to a variable named `days`. Convert `days` to a float." 257 | ] 258 | }, 259 | { 260 | "cell_type": "code", 261 | "execution_count": null, 262 | "metadata": {}, 263 | "outputs": [], 264 | "source": [] 265 | }, 266 | { 267 | "cell_type": "markdown", 268 | "metadata": {}, 269 | "source": [ 270 | "#### 1.3 \n", 271 | "See what happens when you execute\n", 272 | "\n", 273 | "```julia\n", 274 | "convert(Int64, \"1\")\n", 275 | "```\n", 276 | "and\n", 277 | "\n", 278 | "```julia\n", 279 | "parse(Int64, \"1\")\n", 280 | "```" 281 | ] 282 | }, 283 | { 284 | "cell_type": "code", 285 | "execution_count": null, 286 | "metadata": {}, 287 | "outputs": [], 288 | "source": [] 289 | } 290 | ], 291 | "metadata": { 292 | "kernelspec": { 293 | "display_name": "Julia 1.0.0", 294 | "language": "julia", 295 | "name": "julia-1.0" 296 | }, 297 | "language_info": { 298 | "file_extension": ".jl", 299 | "mimetype": "application/julia", 300 | "name": "julia", 301 | "version": "1.0.0" 302 | } 303 | }, 304 | "nbformat": 4, 305 | "nbformat_minor": 2 306 | } 307 | -------------------------------------------------------------------------------- /02.Strings.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Strings\n", 10 | "\n", 11 | "Topics:\n", 12 | "1. How to get a string\n", 13 | "2. String interpolation\n", 14 | "3. String concatenation" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "## How to get a string\n", 22 | "\n", 23 | "Enclose your characters in \" \" or \"\"\" \"\"\"!" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": null, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "s1 = \"I am a string.\"" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": null, 38 | "metadata": {}, 39 | "outputs": [], 40 | "source": [ 41 | "s2 = \"\"\"I am also a string. \"\"\"" 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "There are a couple functional differences between strings enclosed in single and triple quotes.
\n", 49 | "One difference is that, in the latter case, you can use quotation marks within your string." 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": null, 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [ 58 | "\"Here, we get an \"error\" because it's ambiguous where this string ends \"" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": null, 64 | "metadata": {}, 65 | "outputs": [], 66 | "source": [ 67 | "\"\"\"Look, Mom, no \"errors\"!!! \"\"\"" 68 | ] 69 | }, 70 | { 71 | "cell_type": "markdown", 72 | "metadata": {}, 73 | "source": [ 74 | "Note that ' ' define a character, but NOT a string!" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": null, 80 | "metadata": {}, 81 | "outputs": [], 82 | "source": [ 83 | "typeof('a')" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": null, 89 | "metadata": {}, 90 | "outputs": [], 91 | "source": [ 92 | "'We will get an error here'" 93 | ] 94 | }, 95 | { 96 | "cell_type": "markdown", 97 | "metadata": {}, 98 | "source": [ 99 | "## String interpolation\n", 100 | "\n", 101 | "We can use the $ sign to insert existing variables into a string and to evaluate expressions within a string.
\n", 102 | "Below is an example that contains some highly sensitive personal information." 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": null, 108 | "metadata": {}, 109 | "outputs": [], 110 | "source": [ 111 | "name = \"Jane\"\n", 112 | "num_fingers = 10\n", 113 | "num_toes = 10" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": null, 119 | "metadata": {}, 120 | "outputs": [], 121 | "source": [ 122 | "println(\"Hello, my name is $name.\")\n", 123 | "println(\"I have $num_fingers fingers and $num_toes toes.\")" 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": null, 129 | "metadata": {}, 130 | "outputs": [], 131 | "source": [ 132 | " println(\"That is $(num_fingers + num_toes) digits in all!!\")" 133 | ] 134 | }, 135 | { 136 | "cell_type": "markdown", 137 | "metadata": {}, 138 | "source": [ 139 | "## String concatenation\n", 140 | "\n", 141 | "Below are three ways we can concatenate strings!

\n", 142 | "The first way is to use the `string()` function.
\n", 143 | "`string()` converts non-string inputs to strings." 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": null, 149 | "metadata": {}, 150 | "outputs": [], 151 | "source": [ 152 | "s3 = \"How many cats \";\n", 153 | "s4 = \"is too many cats?\";\n", 154 | "😺 = 10" 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": null, 160 | "metadata": {}, 161 | "outputs": [], 162 | "source": [ 163 | "string(s3, s4)" 164 | ] 165 | }, 166 | { 167 | "cell_type": "code", 168 | "execution_count": null, 169 | "metadata": {}, 170 | "outputs": [], 171 | "source": [ 172 | "string(\"I don't know, but \", 😺, \" is too few.\")" 173 | ] 174 | }, 175 | { 176 | "cell_type": "markdown", 177 | "metadata": {}, 178 | "source": [ 179 | "We can also use `*` for concatenation!" 180 | ] 181 | }, 182 | { 183 | "cell_type": "code", 184 | "execution_count": null, 185 | "metadata": {}, 186 | "outputs": [], 187 | "source": [ 188 | "s3*s4" 189 | ] 190 | }, 191 | { 192 | "cell_type": "markdown", 193 | "metadata": {}, 194 | "source": [ 195 | "### Exercises\n", 196 | "\n", 197 | "#### 2.1 \n", 198 | "Create a string that says \"hi\" 1000 times, first with `repeat` and then with the exponentiation operator, which can call `*` under the hood." 199 | ] 200 | }, 201 | { 202 | "cell_type": "code", 203 | "execution_count": null, 204 | "metadata": {}, 205 | "outputs": [], 206 | "source": [] 207 | }, 208 | { 209 | "cell_type": "markdown", 210 | "metadata": {}, 211 | "source": [ 212 | "#### 2.2 \n", 213 | "Declare two variables\n", 214 | "\n", 215 | "```julia\n", 216 | "a = 3\n", 217 | "b = 4\n", 218 | "```\n", 219 | "and use them to create two strings:\n", 220 | "```julia\n", 221 | "\"3 + 4\"\n", 222 | "\"7\"\n", 223 | "```" 224 | ] 225 | }, 226 | { 227 | "cell_type": "code", 228 | "execution_count": null, 229 | "metadata": {}, 230 | "outputs": [], 231 | "source": [] 232 | } 233 | ], 234 | "metadata": { 235 | "kernelspec": { 236 | "display_name": "Julia 1.0.0", 237 | "language": "julia", 238 | "name": "julia-1.0" 239 | }, 240 | "language_info": { 241 | "file_extension": ".jl", 242 | "mimetype": "application/julia", 243 | "name": "julia", 244 | "version": "1.0.0" 245 | } 246 | }, 247 | "nbformat": 4, 248 | "nbformat_minor": 2 249 | } 250 | -------------------------------------------------------------------------------- /04.Loops.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Loops\n", 10 | "\n", 11 | "Topics:\n", 12 | "1. `while` loops\n", 13 | "2. `for` loops\n", 14 | "
\n", 15 | "\n", 16 | "## while loops\n", 17 | "\n", 18 | "The syntax for a `while` is\n", 19 | "\n", 20 | "```julia\n", 21 | "while *condition*\n", 22 | " *loop body*\n", 23 | "end\n", 24 | "```\n", 25 | "\n", 26 | "For example, we could use `while` to count or to iterate over an array." 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": null, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "n = 0\n", 36 | "while n < 10\n", 37 | " n += 1\n", 38 | " println(n)\n", 39 | "end\n", 40 | "n" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": null, 46 | "metadata": {}, 47 | "outputs": [], 48 | "source": [ 49 | "myfriends = [\"Ted\", \"Robyn\", \"Barney\", \"Lily\", \"Marshall\"]\n", 50 | "\n", 51 | "i = 1\n", 52 | "while i <= length(myfriends)\n", 53 | " friend = myfriends[i]\n", 54 | " println(\"Hi $friend, it's great to see you!\")\n", 55 | " i += 1\n", 56 | "end" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "## for loops\n", 64 | "\n", 65 | "The syntax for a `for` loop is\n", 66 | "\n", 67 | "```julia\n", 68 | "for *var* in *loop iterable*\n", 69 | " *loop body*\n", 70 | "end\n", 71 | "```\n", 72 | "\n", 73 | "We could use a for loop to generate the same results as either of the examples above:" 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": null, 79 | "metadata": {}, 80 | "outputs": [], 81 | "source": [ 82 | "for n in 1:10\n", 83 | " println(n)\n", 84 | "end" 85 | ] 86 | }, 87 | { 88 | "cell_type": "code", 89 | "execution_count": null, 90 | "metadata": {}, 91 | "outputs": [], 92 | "source": [ 93 | "myfriends = [\"Ted\", \"Robyn\", \"Barney\", \"Lily\", \"Marshall\"]\n", 94 | "\n", 95 | "for friend in myfriends\n", 96 | " println(\"Hi $friend, it's great to see you!\")\n", 97 | "end" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "Now let's use `for` loops to create some addition tables, where the value of every entry is the sum of its row and column indices.
\n", 105 | "\n", 106 | "First, we initialize an array with zeros." 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": null, 112 | "metadata": {}, 113 | "outputs": [], 114 | "source": [ 115 | "m, n = 5, 5\n", 116 | "A = fill(0, (m, n))" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": null, 122 | "metadata": {}, 123 | "outputs": [], 124 | "source": [ 125 | "for i in 1:m\n", 126 | " for j in 1:n\n", 127 | " A[i, j] = i + j\n", 128 | " end\n", 129 | "end\n", 130 | "A" 131 | ] 132 | }, 133 | { 134 | "cell_type": "markdown", 135 | "metadata": {}, 136 | "source": [ 137 | "Here's some syntactic sugar for the same nested `for` loop" 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": null, 143 | "metadata": {}, 144 | "outputs": [], 145 | "source": [ 146 | "B = fill(0, (m, n))" 147 | ] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": null, 152 | "metadata": {}, 153 | "outputs": [], 154 | "source": [ 155 | "for i in 1:m, j in 1:n\n", 156 | " B[i, j] = i + j\n", 157 | "end\n", 158 | "B" 159 | ] 160 | }, 161 | { 162 | "cell_type": "markdown", 163 | "metadata": {}, 164 | "source": [ 165 | "The more \"Julia\" way to create this addition table would have been with an *array comprehension*." 166 | ] 167 | }, 168 | { 169 | "cell_type": "code", 170 | "execution_count": null, 171 | "metadata": {}, 172 | "outputs": [], 173 | "source": [ 174 | "C = [i + j for i in 1:m, j in 1:n]" 175 | ] 176 | }, 177 | { 178 | "cell_type": "markdown", 179 | "metadata": {}, 180 | "source": [ 181 | "### Exercises\n", 182 | "\n", 183 | "#### 4.1 \n", 184 | "Loop over integers between 1 and 100 and print their squares." 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": null, 190 | "metadata": {}, 191 | "outputs": [], 192 | "source": [] 193 | }, 194 | { 195 | "cell_type": "markdown", 196 | "metadata": {}, 197 | "source": [ 198 | "#### 4.2 \n", 199 | "Add to the code above a bit to create a dictionary, `squares` that holds integers and their squares as key, value pairs such that\n", 200 | "\n", 201 | "```julia\n", 202 | "squares[10] == 100\n", 203 | "```" 204 | ] 205 | }, 206 | { 207 | "cell_type": "code", 208 | "execution_count": null, 209 | "metadata": {}, 210 | "outputs": [], 211 | "source": [] 212 | }, 213 | { 214 | "cell_type": "markdown", 215 | "metadata": { 216 | "collapsed": true 217 | }, 218 | "source": [ 219 | "#### 4.3 \n", 220 | "Use an array comprehension to create an an array that stores the squares for all integers between 1 and 100." 221 | ] 222 | }, 223 | { 224 | "cell_type": "code", 225 | "execution_count": null, 226 | "metadata": {}, 227 | "outputs": [], 228 | "source": [] 229 | } 230 | ], 231 | "metadata": { 232 | "kernelspec": { 233 | "display_name": "Julia 1.0.0", 234 | "language": "julia", 235 | "name": "julia-1.0" 236 | }, 237 | "language_info": { 238 | "file_extension": ".jl", 239 | "mimetype": "application/julia", 240 | "name": "julia", 241 | "version": "1.0.0" 242 | } 243 | }, 244 | "nbformat": 4, 245 | "nbformat_minor": 2 246 | } 247 | -------------------------------------------------------------------------------- /05.Conditionals.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Conditionals\n", 10 | "\n", 11 | "#### with the `if` keyword\n", 12 | "In Julia, the syntax\n", 13 | "\n", 14 | "```julia\n", 15 | "if *condition 1*\n", 16 | " *option 1*\n", 17 | "elseif *condition 2*\n", 18 | " *option 2*\n", 19 | "else\n", 20 | " *option 3*\n", 21 | "end\n", 22 | "```\n", 23 | "\n", 24 | "allows us to conditionally evaluate one of our options.\n", 25 | "

\n", 26 | "For example, we might want to implement the FizzBuzz test: given a number, N, print \"Fizz\" if N is divisible by 3, \"Buzz\" if N is divisible by 5, and \"FizzBuzz\" if N is divisible by 3 and 5. Otherwise just print the number itself! Enter your choice for `N` here:" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": null, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "N = " 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": null, 41 | "metadata": {}, 42 | "outputs": [], 43 | "source": [ 44 | "if (N % 3 == 0) && (N % 5 == 0) # `&&` means \"AND\"; % computes the remainder after division\n", 45 | " println(\"FizzBuzz\")\n", 46 | "elseif N % 3 == 0\n", 47 | " println(\"Fizz\")\n", 48 | "elseif N % 5 == 0\n", 49 | " println(\"Buzz\")\n", 50 | "else\n", 51 | " println(N)\n", 52 | "end" 53 | ] 54 | }, 55 | { 56 | "cell_type": "markdown", 57 | "metadata": {}, 58 | "source": [ 59 | "#### with ternary operators\n", 60 | "\n", 61 | "For this last block, we could instead use the ternary operator with the syntax\n", 62 | "\n", 63 | "```julia\n", 64 | "a ? b : c\n", 65 | "```\n", 66 | "\n", 67 | "which equates to \n", 68 | "\n", 69 | "```julia\n", 70 | "if a\n", 71 | " b\n", 72 | "else\n", 73 | " c\n", 74 | "end\n", 75 | "```" 76 | ] 77 | }, 78 | { 79 | "cell_type": "markdown", 80 | "metadata": {}, 81 | "source": [ 82 | "Now let's say we want to return the larger of two numbers. Give `x` and `y` values here:" 83 | ] 84 | }, 85 | { 86 | "cell_type": "code", 87 | "execution_count": null, 88 | "metadata": {}, 89 | "outputs": [], 90 | "source": [ 91 | "x =\n", 92 | "y =" 93 | ] 94 | }, 95 | { 96 | "cell_type": "markdown", 97 | "metadata": {}, 98 | "source": [ 99 | "Using the `if` and `else` keywords, we might write:" 100 | ] 101 | }, 102 | { 103 | "cell_type": "code", 104 | "execution_count": null, 105 | "metadata": {}, 106 | "outputs": [], 107 | "source": [ 108 | "if x > y\n", 109 | " x\n", 110 | "else\n", 111 | " y\n", 112 | "end" 113 | ] 114 | }, 115 | { 116 | "cell_type": "markdown", 117 | "metadata": {}, 118 | "source": [ 119 | "and as a ternary operator, the conditional looks like this:" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": null, 125 | "metadata": {}, 126 | "outputs": [], 127 | "source": [ 128 | "(x > y) ? x : y" 129 | ] 130 | }, 131 | { 132 | "cell_type": "markdown", 133 | "metadata": {}, 134 | "source": [ 135 | "#### with short-circuit evaluation\n", 136 | "\n", 137 | "We've already seen expressions with the syntax\n", 138 | "```julia\n", 139 | "a && b\n", 140 | "```\n", 141 | "to return true if both `a` and `b` are true. Of course, if `a` is false, Julia doesn't even need to know the value of `b` in order to determine that the overall result will be false. So Julia doesn't even need to check what `b` is; it can just \"short-circuit\" and immediately return `false`. The second argument `b` might be a more complicated expression like a function call with a side-effect, in which case it won't even be called:" 142 | ] 143 | }, 144 | { 145 | "cell_type": "code", 146 | "execution_count": null, 147 | "metadata": {}, 148 | "outputs": [], 149 | "source": [ 150 | "false && (println(\"hi\"); true)" 151 | ] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "execution_count": null, 156 | "metadata": {}, 157 | "outputs": [], 158 | "source": [ 159 | "true && (println(\"hi\"); true)" 160 | ] 161 | }, 162 | { 163 | "cell_type": "markdown", 164 | "metadata": {}, 165 | "source": [ 166 | "On the other hand, if `a` is true, Julia knows it can just return the value of `b` as the overall expression. This means that `b` doesn't necessarily need evaluate to `true` or `false`! `b` could even be an error:" 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": null, 172 | "metadata": {}, 173 | "outputs": [], 174 | "source": [ 175 | "(x > 0) && error(\"x cannot be greater than 0\")" 176 | ] 177 | }, 178 | { 179 | "cell_type": "markdown", 180 | "metadata": {}, 181 | "source": [ 182 | "Similarly, check out the `||` operator, which also uses short-circuit evaluation to perform the \"or\" operation." 183 | ] 184 | }, 185 | { 186 | "cell_type": "code", 187 | "execution_count": null, 188 | "metadata": {}, 189 | "outputs": [], 190 | "source": [ 191 | "true || println(\"hi\")" 192 | ] 193 | }, 194 | { 195 | "cell_type": "markdown", 196 | "metadata": {}, 197 | "source": [ 198 | "and" 199 | ] 200 | }, 201 | { 202 | "cell_type": "code", 203 | "execution_count": null, 204 | "metadata": {}, 205 | "outputs": [], 206 | "source": [ 207 | "false || println(\"hi\")" 208 | ] 209 | }, 210 | { 211 | "cell_type": "markdown", 212 | "metadata": { 213 | "collapsed": true 214 | }, 215 | "source": [ 216 | "### Exercises\n", 217 | "\n", 218 | "#### 5.1 \n", 219 | "Write a conditional statement that prints a number if the number is even and the string \"odd\" if the number is odd." 220 | ] 221 | }, 222 | { 223 | "cell_type": "code", 224 | "execution_count": null, 225 | "metadata": {}, 226 | "outputs": [], 227 | "source": [] 228 | }, 229 | { 230 | "cell_type": "markdown", 231 | "metadata": {}, 232 | "source": [ 233 | "#### 5.2 \n", 234 | "Rewrite the code from 5.1 using a ternary operator." 235 | ] 236 | }, 237 | { 238 | "cell_type": "code", 239 | "execution_count": null, 240 | "metadata": {}, 241 | "outputs": [], 242 | "source": [] 243 | } 244 | ], 245 | "metadata": { 246 | "kernelspec": { 247 | "display_name": "Julia 1.0.0", 248 | "language": "julia", 249 | "name": "julia-1.0" 250 | }, 251 | "language_info": { 252 | "file_extension": ".jl", 253 | "mimetype": "application/julia", 254 | "name": "julia", 255 | "version": "1.0.0" 256 | } 257 | }, 258 | "nbformat": 4, 259 | "nbformat_minor": 2 260 | } 261 | -------------------------------------------------------------------------------- /06.Functions.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Functions\n", 8 | "\n", 9 | "Topics:\n", 10 | "1. How to declare a function\n", 11 | "2. Duck-typing in Julia\n", 12 | "3. Mutating vs. non-mutating functions\n", 13 | "4. Some higher order functions" 14 | ] 15 | }, 16 | { 17 | "cell_type": "markdown", 18 | "metadata": {}, 19 | "source": [ 20 | "## How to declare a function\n", 21 | "Julia gives us a few different ways to write a function. The first requires the `function` and `end` keywords" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": null, 27 | "metadata": {}, 28 | "outputs": [], 29 | "source": [ 30 | "function sayhi(name)\n", 31 | " println(\"Hi $name, it's great to see you!\")\n", 32 | "end" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": null, 38 | "metadata": {}, 39 | "outputs": [], 40 | "source": [ 41 | "function f(x)\n", 42 | " x^2\n", 43 | "end" 44 | ] 45 | }, 46 | { 47 | "cell_type": "markdown", 48 | "metadata": {}, 49 | "source": [ 50 | "We can call either of these functions like this:" 51 | ] 52 | }, 53 | { 54 | "cell_type": "code", 55 | "execution_count": null, 56 | "metadata": {}, 57 | "outputs": [], 58 | "source": [ 59 | "sayhi(\"C-3PO\")" 60 | ] 61 | }, 62 | { 63 | "cell_type": "code", 64 | "execution_count": null, 65 | "metadata": {}, 66 | "outputs": [], 67 | "source": [ 68 | "f(42)" 69 | ] 70 | }, 71 | { 72 | "cell_type": "markdown", 73 | "metadata": {}, 74 | "source": [ 75 | "Alternatively, we could have declared either of these functions in a single line" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": null, 81 | "metadata": {}, 82 | "outputs": [], 83 | "source": [ 84 | "sayhi2(name) = println(\"Hi $name, it's great to see you!\")" 85 | ] 86 | }, 87 | { 88 | "cell_type": "code", 89 | "execution_count": null, 90 | "metadata": {}, 91 | "outputs": [], 92 | "source": [ 93 | "f2(x) = x^2" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": null, 99 | "metadata": {}, 100 | "outputs": [], 101 | "source": [ 102 | "sayhi2(\"R2D2\")" 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": null, 108 | "metadata": {}, 109 | "outputs": [], 110 | "source": [ 111 | "f2(42)" 112 | ] 113 | }, 114 | { 115 | "cell_type": "markdown", 116 | "metadata": {}, 117 | "source": [ 118 | "Finally, we could have declared these as \"anonymous\" functions" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": null, 124 | "metadata": {}, 125 | "outputs": [], 126 | "source": [ 127 | "sayhi3 = name -> println(\"Hi $name, it's great to see you!\")" 128 | ] 129 | }, 130 | { 131 | "cell_type": "code", 132 | "execution_count": null, 133 | "metadata": {}, 134 | "outputs": [], 135 | "source": [ 136 | "f3 = x -> x^2" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": null, 142 | "metadata": {}, 143 | "outputs": [], 144 | "source": [ 145 | "sayhi3(\"Chewbacca\")" 146 | ] 147 | }, 148 | { 149 | "cell_type": "code", 150 | "execution_count": null, 151 | "metadata": {}, 152 | "outputs": [], 153 | "source": [ 154 | "f3(42)" 155 | ] 156 | }, 157 | { 158 | "cell_type": "markdown", 159 | "metadata": {}, 160 | "source": [ 161 | "## Duck-typing in Julia\n", 162 | "*\"If it quacks like a duck, it's a duck.\"*

\n", 163 | "Julia functions will just work on whatever inputs make sense.

\n", 164 | "For example, `sayhi` works on the name of this minor tv character, written as an integer..." 165 | ] 166 | }, 167 | { 168 | "cell_type": "code", 169 | "execution_count": null, 170 | "metadata": {}, 171 | "outputs": [], 172 | "source": [ 173 | "sayhi(55595472)" 174 | ] 175 | }, 176 | { 177 | "cell_type": "markdown", 178 | "metadata": {}, 179 | "source": [ 180 | "And `f` will work on a matrix. " 181 | ] 182 | }, 183 | { 184 | "cell_type": "code", 185 | "execution_count": null, 186 | "metadata": {}, 187 | "outputs": [], 188 | "source": [ 189 | "A = rand(3, 3)\n", 190 | "A" 191 | ] 192 | }, 193 | { 194 | "cell_type": "code", 195 | "execution_count": null, 196 | "metadata": {}, 197 | "outputs": [], 198 | "source": [ 199 | "f(A)" 200 | ] 201 | }, 202 | { 203 | "cell_type": "markdown", 204 | "metadata": {}, 205 | "source": [ 206 | "`f` will also work on a string like \"hi\" because `*` is defined for string inputs as string concatenation." 207 | ] 208 | }, 209 | { 210 | "cell_type": "code", 211 | "execution_count": null, 212 | "metadata": {}, 213 | "outputs": [], 214 | "source": [ 215 | "f(\"hi\")" 216 | ] 217 | }, 218 | { 219 | "cell_type": "markdown", 220 | "metadata": {}, 221 | "source": [ 222 | "On the other hand, `f` will not work on a vector. Unlike `A^2`, which is well-defined, the meaning of `v^2` for a vector, `v`, is not a well-defined algebraic operation. " 223 | ] 224 | }, 225 | { 226 | "cell_type": "code", 227 | "execution_count": null, 228 | "metadata": {}, 229 | "outputs": [], 230 | "source": [ 231 | "v = rand(3)" 232 | ] 233 | }, 234 | { 235 | "cell_type": "code", 236 | "execution_count": null, 237 | "metadata": {}, 238 | "outputs": [], 239 | "source": [ 240 | "f(v)" 241 | ] 242 | }, 243 | { 244 | "cell_type": "markdown", 245 | "metadata": { 246 | "collapsed": true 247 | }, 248 | "source": [ 249 | "## Mutating vs. non-mutating functions\n", 250 | "\n", 251 | "By convention, functions followed by `!` alter their contents and functions lacking `!` do not.\n", 252 | "\n", 253 | "For example, let's look at the difference between `sort` and `sort!`.\n" 254 | ] 255 | }, 256 | { 257 | "cell_type": "code", 258 | "execution_count": null, 259 | "metadata": {}, 260 | "outputs": [], 261 | "source": [ 262 | "v = [3, 5, 2]" 263 | ] 264 | }, 265 | { 266 | "cell_type": "code", 267 | "execution_count": null, 268 | "metadata": {}, 269 | "outputs": [], 270 | "source": [ 271 | "sort(v)" 272 | ] 273 | }, 274 | { 275 | "cell_type": "code", 276 | "execution_count": null, 277 | "metadata": {}, 278 | "outputs": [], 279 | "source": [ 280 | "v" 281 | ] 282 | }, 283 | { 284 | "cell_type": "markdown", 285 | "metadata": {}, 286 | "source": [ 287 | "`sort(v)` returns a sorted array that contains the same elements as `v`, but `v` is left unchanged.

\n", 288 | "\n", 289 | "On the other hand, when we run `sort!(v)`, the contents of v are sorted within the array `v`." 290 | ] 291 | }, 292 | { 293 | "cell_type": "code", 294 | "execution_count": null, 295 | "metadata": {}, 296 | "outputs": [], 297 | "source": [ 298 | "sort!(v)" 299 | ] 300 | }, 301 | { 302 | "cell_type": "code", 303 | "execution_count": null, 304 | "metadata": {}, 305 | "outputs": [], 306 | "source": [ 307 | "v" 308 | ] 309 | }, 310 | { 311 | "cell_type": "markdown", 312 | "metadata": {}, 313 | "source": [ 314 | "## Some higher order functions\n", 315 | "\n", 316 | "### map\n", 317 | "\n", 318 | "`map` is a \"higher-order\" function in Julia that *takes a function* as one of its input arguments. \n", 319 | "`map` then applies that function to every element of the data structure you pass it. For example, executing\n", 320 | "\n", 321 | "```julia\n", 322 | "map(f, [1, 2, 3])\n", 323 | "```\n", 324 | "will give you an output array where the function `f` has been applied to all elements of `[1, 2, 3]`\n", 325 | "```julia\n", 326 | "[f(1), f(2), f(3)]\n", 327 | "```" 328 | ] 329 | }, 330 | { 331 | "cell_type": "code", 332 | "execution_count": null, 333 | "metadata": {}, 334 | "outputs": [], 335 | "source": [ 336 | "map(f, [1, 2, 3])" 337 | ] 338 | }, 339 | { 340 | "cell_type": "markdown", 341 | "metadata": {}, 342 | "source": [ 343 | "Here we've squared all the elements of the vector `[1, 2, 3]`, rather than squaring the vector `[1, 2, 3]`.\n", 344 | "\n", 345 | "To do this, we could have passed to `map` an anonymous function rather than a named function, such as" 346 | ] 347 | }, 348 | { 349 | "cell_type": "code", 350 | "execution_count": null, 351 | "metadata": {}, 352 | "outputs": [], 353 | "source": [ 354 | "x -> x^3" 355 | ] 356 | }, 357 | { 358 | "cell_type": "markdown", 359 | "metadata": {}, 360 | "source": [ 361 | "via" 362 | ] 363 | }, 364 | { 365 | "cell_type": "code", 366 | "execution_count": null, 367 | "metadata": {}, 368 | "outputs": [], 369 | "source": [ 370 | "map(x -> x^3, [1, 2, 3])" 371 | ] 372 | }, 373 | { 374 | "cell_type": "markdown", 375 | "metadata": {}, 376 | "source": [ 377 | "and now we've cubed all the elements of `[1, 2, 3]`!" 378 | ] 379 | }, 380 | { 381 | "cell_type": "markdown", 382 | "metadata": {}, 383 | "source": [ 384 | "### broadcast\n", 385 | "\n", 386 | "`broadcast` is another higher-order function like `map`. `broadcast` is a generalization of `map`, so it can do every thing `map` can do and more. The syntax for calling `broadcast` is the same as for calling `map`" 387 | ] 388 | }, 389 | { 390 | "cell_type": "code", 391 | "execution_count": null, 392 | "metadata": {}, 393 | "outputs": [], 394 | "source": [ 395 | "broadcast(f, [1, 2, 3])" 396 | ] 397 | }, 398 | { 399 | "cell_type": "markdown", 400 | "metadata": {}, 401 | "source": [ 402 | "and again, we've applied `f` (squared) to all the elements of `[1, 2, 3]` - this time by \"broadcasting\" `f`!\n", 403 | "\n", 404 | "Some syntactic sugar for calling `broadcast` is to place a `.` between the name of the function you want to `broadcast` and its input arguments. For example,\n", 405 | "\n", 406 | "```julia\n", 407 | "broadcast(f, [1, 2, 3])\n", 408 | "```\n", 409 | "is the same as\n", 410 | "```julia\n", 411 | "f.([1, 2, 3])\n", 412 | "```" 413 | ] 414 | }, 415 | { 416 | "cell_type": "code", 417 | "execution_count": null, 418 | "metadata": {}, 419 | "outputs": [], 420 | "source": [ 421 | "f.([1, 2, 3])" 422 | ] 423 | }, 424 | { 425 | "cell_type": "markdown", 426 | "metadata": {}, 427 | "source": [ 428 | "Notice again how different this is from calling \n", 429 | "```julia\n", 430 | "f([1, 2, 3])\n", 431 | "```\n", 432 | "We can square every element of a vector, but we can't square a vector!" 433 | ] 434 | }, 435 | { 436 | "cell_type": "markdown", 437 | "metadata": {}, 438 | "source": [ 439 | "To drive home the point, let's look at the difference between\n", 440 | "\n", 441 | "```julia\n", 442 | "f(A)\n", 443 | "```\n", 444 | "and\n", 445 | "```julia\n", 446 | "f.(A)\n", 447 | "```\n", 448 | "for a matrix `A`:" 449 | ] 450 | }, 451 | { 452 | "cell_type": "code", 453 | "execution_count": null, 454 | "metadata": {}, 455 | "outputs": [], 456 | "source": [ 457 | "A = [i + 3*j for j in 0:2, i in 1:3]" 458 | ] 459 | }, 460 | { 461 | "cell_type": "code", 462 | "execution_count": null, 463 | "metadata": {}, 464 | "outputs": [], 465 | "source": [ 466 | "f(A)" 467 | ] 468 | }, 469 | { 470 | "cell_type": "markdown", 471 | "metadata": {}, 472 | "source": [ 473 | "As before we see that for a matrix, `A`,\n", 474 | "```\n", 475 | "f(A) = A^2 = A * A\n", 476 | "``` \n", 477 | "\n", 478 | "On the other hand," 479 | ] 480 | }, 481 | { 482 | "cell_type": "code", 483 | "execution_count": null, 484 | "metadata": {}, 485 | "outputs": [], 486 | "source": [ 487 | "B = f.(A)" 488 | ] 489 | }, 490 | { 491 | "cell_type": "markdown", 492 | "metadata": { 493 | "collapsed": true 494 | }, 495 | "source": [ 496 | "contains the squares of all the entries of `A`.\n", 497 | "\n", 498 | "This dot syntax for broadcasting allows us to write relatively complex compound elementwise expressions in a way that looks natural/closer to mathematical notation. For example, we can write" 499 | ] 500 | }, 501 | { 502 | "cell_type": "code", 503 | "execution_count": null, 504 | "metadata": {}, 505 | "outputs": [], 506 | "source": [ 507 | "A .+ 2 .* f.(A) ./ A" 508 | ] 509 | }, 510 | { 511 | "cell_type": "markdown", 512 | "metadata": {}, 513 | "source": [ 514 | "instead of" 515 | ] 516 | }, 517 | { 518 | "cell_type": "code", 519 | "execution_count": null, 520 | "metadata": {}, 521 | "outputs": [], 522 | "source": [ 523 | "broadcast(x -> x + 2 * f(x) / x, A)" 524 | ] 525 | }, 526 | { 527 | "cell_type": "markdown", 528 | "metadata": {}, 529 | "source": [ 530 | "and the two will perform exactly the same." 531 | ] 532 | }, 533 | { 534 | "cell_type": "markdown", 535 | "metadata": { 536 | "collapsed": true 537 | }, 538 | "source": [ 539 | "### Exercises\n", 540 | "\n", 541 | "#### 6.1 \n", 542 | "Write a function that adds 1 to its input." 543 | ] 544 | }, 545 | { 546 | "cell_type": "code", 547 | "execution_count": null, 548 | "metadata": {}, 549 | "outputs": [], 550 | "source": [] 551 | }, 552 | { 553 | "cell_type": "markdown", 554 | "metadata": {}, 555 | "source": [ 556 | "#### 6.2 \n", 557 | "Use `map` or `broadcast` to increment every element of matrix `A` by `1`." 558 | ] 559 | }, 560 | { 561 | "cell_type": "code", 562 | "execution_count": null, 563 | "metadata": {}, 564 | "outputs": [], 565 | "source": [] 566 | }, 567 | { 568 | "cell_type": "markdown", 569 | "metadata": { 570 | "collapsed": true 571 | }, 572 | "source": [ 573 | "#### 6.3 \n", 574 | "Use the broadcast dot syntax to increment every element of matrix `A` by `1`." 575 | ] 576 | }, 577 | { 578 | "cell_type": "code", 579 | "execution_count": null, 580 | "metadata": {}, 581 | "outputs": [], 582 | "source": [] 583 | } 584 | ], 585 | "metadata": { 586 | "kernelspec": { 587 | "display_name": "Julia 1.0.0", 588 | "language": "julia", 589 | "name": "julia-1.0" 590 | }, 591 | "language_info": { 592 | "file_extension": ".jl", 593 | "mimetype": "application/julia", 594 | "name": "julia", 595 | "version": "1.0.0" 596 | } 597 | }, 598 | "nbformat": 4, 599 | "nbformat_minor": 2 600 | } 601 | -------------------------------------------------------------------------------- /07.Packages.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Packages\n", 10 | "\n", 11 | "Julia has over 2000 registered packages, making packages a huge part of the Julia ecosystem.\n", 12 | "\n", 13 | "Even so, the package ecosystem still has some growing to do. Notably, we have first class function calls to other languages, providing excellent foreign function interfaces. We can easily call into python or R, for example, with `PyCall` or `Rcall`.\n", 14 | "\n", 15 | "This means that you don't have to wait until the Julia ecosystem is fully mature, and that moving to Julia doesn't mean you have to give up your favorite package/library from another language! \n", 16 | "\n", 17 | "To see all available packages, check out\n", 18 | "\n", 19 | "https://pkg.julialang.org/\n", 20 | "or\n", 21 | "https://juliaobserver.com/\n", 22 | "\n", 23 | "For now, let's learn how to use a package." 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": {}, 29 | "source": [ 30 | "The first time you use a package on a given Julia installation, you need to use the package manager to explicitly add it:" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": null, 36 | "metadata": {}, 37 | "outputs": [], 38 | "source": [ 39 | "using Pkg\n", 40 | "Pkg.add(\"Example\")" 41 | ] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "metadata": {}, 46 | "source": [ 47 | "Every time you use Julia (start a new session at the REPL, or open a notebook for the first time, for example), you load the package with the `using` keyword" 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": null, 53 | "metadata": {}, 54 | "outputs": [], 55 | "source": [ 56 | "using Example" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "In the source code of `Example.jl` at\n", 64 | "https://github.com/JuliaLang/Example.jl/blob/master/src/Example.jl\n", 65 | "we see the following function declared\n", 66 | "\n", 67 | "```\n", 68 | "hello(who::String) = \"Hello, $who\"\n", 69 | "```\n", 70 | "\n", 71 | "Having loaded `Example`, we should now be able to call `hello`" 72 | ] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": null, 77 | "metadata": {}, 78 | "outputs": [], 79 | "source": [ 80 | "hello(\"it's me. I was wondering if after all these years you'd like to meet.\")" 81 | ] 82 | }, 83 | { 84 | "cell_type": "markdown", 85 | "metadata": {}, 86 | "source": [ 87 | "Now let's play with the Colors package" 88 | ] 89 | }, 90 | { 91 | "cell_type": "code", 92 | "execution_count": null, 93 | "metadata": {}, 94 | "outputs": [], 95 | "source": [ 96 | "Pkg.add(\"Colors\")" 97 | ] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "execution_count": null, 102 | "metadata": {}, 103 | "outputs": [], 104 | "source": [ 105 | "using Colors" 106 | ] 107 | }, 108 | { 109 | "cell_type": "markdown", 110 | "metadata": {}, 111 | "source": [ 112 | "Let's create a palette of 100 different colors" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": null, 118 | "metadata": {}, 119 | "outputs": [], 120 | "source": [ 121 | "palette = distinguishable_colors(100)" 122 | ] 123 | }, 124 | { 125 | "cell_type": "markdown", 126 | "metadata": {}, 127 | "source": [ 128 | "and then we can create a randomly checkered matrix using the `rand` command" 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": null, 134 | "metadata": {}, 135 | "outputs": [], 136 | "source": [ 137 | "rand(palette, 3, 3)" 138 | ] 139 | }, 140 | { 141 | "cell_type": "markdown", 142 | "metadata": {}, 143 | "source": [ 144 | "In the next notebook, we'll use a new package to plot datasets." 145 | ] 146 | }, 147 | { 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "### Exercises\n", 152 | "\n", 153 | "#### 7.1 \n", 154 | "Load the Primes package (source code at https://github.com/JuliaMath/Primes.jl)." 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": null, 160 | "metadata": {}, 161 | "outputs": [], 162 | "source": [] 163 | }, 164 | { 165 | "cell_type": "markdown", 166 | "metadata": {}, 167 | "source": [ 168 | "#### 7.2 \n", 169 | "Verify that you can now use the function `primes` to grab all prime numbers under 1,000,000." 170 | ] 171 | }, 172 | { 173 | "cell_type": "code", 174 | "execution_count": null, 175 | "metadata": {}, 176 | "outputs": [], 177 | "source": [] 178 | } 179 | ], 180 | "metadata": { 181 | "kernelspec": { 182 | "display_name": "Julia 1.0.0", 183 | "language": "julia", 184 | "name": "julia-1.0" 185 | }, 186 | "language_info": { 187 | "file_extension": ".jl", 188 | "mimetype": "application/julia", 189 | "name": "julia", 190 | "version": "1.0.0" 191 | } 192 | }, 193 | "nbformat": 4, 194 | "nbformat_minor": 2 195 | } 196 | -------------------------------------------------------------------------------- /08.Plotting.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Plotting\n", 8 | "\n", 9 | "## Basics\n", 10 | "There are a few different ways to plot in Julia (including calling PyPlot).
\n", 11 | "\n", 12 | "Here we'll show you how to use `Plots.jl`. If it's not installed yet, you need to use the package manager to install it, and Julia will precompile it for you the first time you use it:" 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": null, 18 | "metadata": {}, 19 | "outputs": [], 20 | "source": [ 21 | "# using Pkg\n", 22 | "# Pkg.add(\"Plots\")\n", 23 | "using Plots" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": {}, 29 | "source": [ 30 | "One of the advantages to `Plots.jl` is that it allows you to seamlessly change backends. In this notebook, we'll try out the `gr()` and `plotlyjs()` backends.
\n", 31 | "\n", 32 | "In the name of scientific inquiry, let's use this notebook to examine the relationship between the global temperature and the number of pirates between roughly 1860 and 2000." 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": null, 38 | "metadata": {}, 39 | "outputs": [], 40 | "source": [ 41 | "globaltemperatures = [14.4, 14.5, 14.8, 15.2, 15.5, 15.8]\n", 42 | "numpirates = [45000, 20000, 15000, 5000, 400, 17];" 43 | ] 44 | }, 45 | { 46 | "cell_type": "markdown", 47 | "metadata": {}, 48 | "source": [ 49 | "Plots supports multiple backends — that is, libraries that actually do the drawing — all with the same API. To start out, let's try the GR backend. You choose it with a call to `gr()`:" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": null, 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [ 58 | "gr()" 59 | ] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "metadata": {}, 64 | "source": [ 65 | "and now we can use commands like `plot` and `scatter` to generate plots." 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": null, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "plot(numpirates, globaltemperatures, label=\"line\") \n", 75 | "scatter!(numpirates, globaltemperatures, label=\"points\") " 76 | ] 77 | }, 78 | { 79 | "cell_type": "markdown", 80 | "metadata": {}, 81 | "source": [ 82 | "The `!` at the end of the `scatter!` function name makes `scatter!` a mutating function, indicating that the scattered points will be added onto the pre-existing plot.\n", 83 | "\n", 84 | "In contrast, see what happens when you replace `scatter!` in the above with the non-mutating function `scatter`.\n", 85 | "\n", 86 | "Next, let's update this plot with the `xlabel!`, `ylabel!`, and `title!` commands to add more information to our plot." 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": null, 92 | "metadata": {}, 93 | "outputs": [], 94 | "source": [ 95 | "xlabel!(\"Number of Pirates [Approximate]\")\n", 96 | "ylabel!(\"Global Temperature (C)\")\n", 97 | "title!(\"Influence of pirate population on global warming\")" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "This still doesn't look quite right. The number of pirates has decreased since 1860, so reading the plot from left to right is like looking backwards in time rather than forwards. Let's flip the x axis to better see how pirate populations have caused global temperatures to change over time!" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": null, 110 | "metadata": {}, 111 | "outputs": [], 112 | "source": [ 113 | "xflip!()" 114 | ] 115 | }, 116 | { 117 | "cell_type": "markdown", 118 | "metadata": {}, 119 | "source": [ 120 | "And there we have it!\n", 121 | "\n", 122 | "Note: We've had some confusion about this exercise. :) This is a joke about how people often conflate correlation and causation.\n", 123 | "\n", 124 | "**Without changing syntax, we can create this plot with the UnicodePlots backend**" 125 | ] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": null, 130 | "metadata": {}, 131 | "outputs": [], 132 | "source": [ 133 | "Pkg.add(\"UnicodePlots\")\n", 134 | "unicodeplots()" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": null, 140 | "metadata": {}, 141 | "outputs": [], 142 | "source": [ 143 | "plot(numpirates, globaltemperatures, label=\"line\") \n", 144 | "scatter!(numpirates, globaltemperatures, label=\"points\") \n", 145 | "xlabel!(\"Number of Pirates [Approximate]\")\n", 146 | "ylabel!(\"Global Temperature (C)\")\n", 147 | "title!(\"Influence of pirate population on global warming\")" 148 | ] 149 | }, 150 | { 151 | "cell_type": "markdown", 152 | "metadata": { 153 | "collapsed": true 154 | }, 155 | "source": [ 156 | "And notice how this second plot differs from the first! Using text like this is a little silly in a Jupyter notebook where we have fancy drawing capabilities, but it can be very useful for quick and dirty visualization in a terminal." 157 | ] 158 | }, 159 | { 160 | "cell_type": "markdown", 161 | "metadata": { 162 | "collapsed": true 163 | }, 164 | "source": [ 165 | "### Exercises\n", 166 | "\n", 167 | "#### 8.1 \n", 168 | "Given\n", 169 | "```julia\n", 170 | "x = -10:10\n", 171 | "```\n", 172 | "plot y vs. x for $y = x^2$. You may want to change backends back again." 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": null, 178 | "metadata": {}, 179 | "outputs": [], 180 | "source": [] 181 | }, 182 | { 183 | "cell_type": "markdown", 184 | "metadata": {}, 185 | "source": [ 186 | "#### 8.2 \n", 187 | "Execute the following code" 188 | ] 189 | }, 190 | { 191 | "cell_type": "code", 192 | "execution_count": null, 193 | "metadata": {}, 194 | "outputs": [], 195 | "source": [ 196 | "p1 = plot(x, x)\n", 197 | "p2 = plot(x, x.^2)\n", 198 | "p3 = plot(x, x.^3)\n", 199 | "p4 = plot(x, x.^4)\n", 200 | "plot(p1, p2, p3, p4, layout = (2, 2), legend = false)" 201 | ] 202 | }, 203 | { 204 | "cell_type": "markdown", 205 | "metadata": {}, 206 | "source": [ 207 | "and then create a $4x1$ plot that uses `p1`, `p2`, `p3`, and `p4` as subplots." 208 | ] 209 | }, 210 | { 211 | "cell_type": "code", 212 | "execution_count": null, 213 | "metadata": {}, 214 | "outputs": [], 215 | "source": [] 216 | } 217 | ], 218 | "metadata": { 219 | "anaconda-cloud": {}, 220 | "kernelspec": { 221 | "display_name": "Julia 1.0.0", 222 | "language": "julia", 223 | "name": "julia-1.0" 224 | }, 225 | "language_info": { 226 | "file_extension": ".jl", 227 | "mimetype": "application/julia", 228 | "name": "julia", 229 | "version": "1.0.0" 230 | }, 231 | "toc": { 232 | "nav_menu": { 233 | "height": "66px", 234 | "width": "252px" 235 | }, 236 | "navigate_menu": true, 237 | "number_sections": true, 238 | "sideBar": true, 239 | "threshold": "2", 240 | "toc_cell": false, 241 | "toc_section_display": "block", 242 | "toc_window_display": false 243 | } 244 | }, 245 | "nbformat": 4, 246 | "nbformat_minor": 2 247 | } 248 | -------------------------------------------------------------------------------- /10.Multiple_dispatch.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Multiple dispatch" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "In this notebook we'll explore **multiple dispatch**, which is a key feature of Julia.\n", 15 | "\n", 16 | "Multiple dispatch makes software *generic* and *fast*!\n", 17 | "\n", 18 | "#### Starting with the familiar\n", 19 | "\n", 20 | "To understand multiple dispatch in Julia, let's start with what we've already seen.\n", 21 | "\n", 22 | "We can declare functions in Julia without giving Julia any information about the types of the input arguments that function will receive:" 23 | ] 24 | }, 25 | { 26 | "cell_type": "code", 27 | "execution_count": null, 28 | "metadata": {}, 29 | "outputs": [], 30 | "source": [ 31 | "f(x) = x^2" 32 | ] 33 | }, 34 | { 35 | "cell_type": "markdown", 36 | "metadata": {}, 37 | "source": [ 38 | "and then Julia will determine on its own which input argument types make sense and which do not:" 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": null, 44 | "metadata": {}, 45 | "outputs": [], 46 | "source": [ 47 | "f(10)" 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": null, 53 | "metadata": {}, 54 | "outputs": [], 55 | "source": [ 56 | "f([1, 2, 3])" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "#### Specifying the types of our input arguments\n", 64 | "\n", 65 | "However, we also have the *option* to tell Julia explicitly what types our input arguments are allowed to have.\n", 66 | "\n", 67 | "For example, let's write a function `foo` that only takes strings as inputs." 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": null, 73 | "metadata": {}, 74 | "outputs": [], 75 | "source": [ 76 | "foo(x::String, y::String) = println(\"My inputs x and y are both strings!\")" 77 | ] 78 | }, 79 | { 80 | "cell_type": "markdown", 81 | "metadata": {}, 82 | "source": [ 83 | "We see here that in order to restrict the type of `x` and `y` to `String`s, we just follow the input argument name by a double colon and the keyword `String`.\n", 84 | "\n", 85 | "Now we'll see that `foo` works on `String`s and doesn't work on other input argument types." 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": null, 91 | "metadata": {}, 92 | "outputs": [], 93 | "source": [ 94 | "foo(\"hello\", \"hi!\")" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": null, 100 | "metadata": {}, 101 | "outputs": [], 102 | "source": [ 103 | "foo(3, 4)" 104 | ] 105 | }, 106 | { 107 | "cell_type": "markdown", 108 | "metadata": {}, 109 | "source": [ 110 | "To get `foo` to work on integer (`Int`) inputs, let's tack `::Int` onto our input arguments when we declare `foo`." 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": null, 116 | "metadata": {}, 117 | "outputs": [], 118 | "source": [ 119 | "foo(x::Int, y::Int) = println(\"My inputs x and y are both integers!\")" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": null, 125 | "metadata": {}, 126 | "outputs": [], 127 | "source": [ 128 | "foo(3, 4)" 129 | ] 130 | }, 131 | { 132 | "cell_type": "markdown", 133 | "metadata": {}, 134 | "source": [ 135 | "Now `foo` works on integers! But look, `foo` also still works when `x` and `y` are strings!" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": null, 141 | "metadata": {}, 142 | "outputs": [], 143 | "source": [ 144 | "foo(\"hello\", \"hi!\")" 145 | ] 146 | }, 147 | { 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "This is starting to get to the heart of multiple dispatch. When we declared\n", 152 | "\n", 153 | "```julia\n", 154 | "foo(x::Int, y::Int) = println(\"My inputs x and y are both integers!\")\n", 155 | "```\n", 156 | "we didn't overwrite or replace\n", 157 | "```julia\n", 158 | "foo(y::String, y::String)```\n", 159 | "\n", 160 | "Instead, we just added an additional ***method*** to the ***generic function*** called `foo`.\n", 161 | "\n", 162 | "A ***generic function*** is the abstract concept associated with a particular operation.\n", 163 | "\n", 164 | "For example, the generic function `+` represents the concept of addition.\n", 165 | "\n", 166 | "A ***method*** is a specific implementation of a generic function for *particular argument types*.\n", 167 | "\n", 168 | "For example, `+` has methods that accept floating point numbers, integers, matrices, etc.\n", 169 | "\n", 170 | "We can use the `methods` to see how many methods there are for `foo`." 171 | ] 172 | }, 173 | { 174 | "cell_type": "code", 175 | "execution_count": null, 176 | "metadata": {}, 177 | "outputs": [], 178 | "source": [ 179 | "methods(foo)" 180 | ] 181 | }, 182 | { 183 | "cell_type": "markdown", 184 | "metadata": {}, 185 | "source": [ 186 | "Aside: how many methods do you think there are for addition?" 187 | ] 188 | }, 189 | { 190 | "cell_type": "code", 191 | "execution_count": null, 192 | "metadata": {}, 193 | "outputs": [], 194 | "source": [ 195 | "methods(+)" 196 | ] 197 | }, 198 | { 199 | "cell_type": "markdown", 200 | "metadata": {}, 201 | "source": [ 202 | "So, we now can call `foo` on integers or strings. When you call `foo` on a particular set of arguments, Julia will infer the types of the inputs and dispatch the appropriate method. *This* is multiple dispatch.\n", 203 | "\n", 204 | "Multiple dispatch makes our code generic and fast. Our code can be generic and flexible because we can write code in terms of abstract operations such as addition and multiplication, rather than in terms of specific implementations. At the same time, our code runs quickly because Julia is able to call efficient methods for the relevant types.\n", 205 | "\n", 206 | "To see which method is being dispatched when we call a generic function, we can use the @which macro:" 207 | ] 208 | }, 209 | { 210 | "cell_type": "code", 211 | "execution_count": null, 212 | "metadata": {}, 213 | "outputs": [], 214 | "source": [ 215 | "@which foo(3, 4)" 216 | ] 217 | }, 218 | { 219 | "cell_type": "markdown", 220 | "metadata": {}, 221 | "source": [ 222 | "Let's see what happens when we use `@which` with the addition operator!" 223 | ] 224 | }, 225 | { 226 | "cell_type": "code", 227 | "execution_count": null, 228 | "metadata": {}, 229 | "outputs": [], 230 | "source": [ 231 | "@which 3.0 + 3.0" 232 | ] 233 | }, 234 | { 235 | "cell_type": "markdown", 236 | "metadata": {}, 237 | "source": [ 238 | "And we can continue to add other methods to our generic function `foo`. Let's add one that takes the ***abstract type*** `Number`, which includes subtypes such as `Int`, `Float64`, and other objects you would think of as numbers:" 239 | ] 240 | }, 241 | { 242 | "cell_type": "code", 243 | "execution_count": null, 244 | "metadata": {}, 245 | "outputs": [], 246 | "source": [ 247 | "foo(x::Number, y::Number) = println(\"My inputs x and y are both numbers!\")" 248 | ] 249 | }, 250 | { 251 | "cell_type": "markdown", 252 | "metadata": {}, 253 | "source": [ 254 | "This method for `foo` will work on, for example, floating point numbers:" 255 | ] 256 | }, 257 | { 258 | "cell_type": "code", 259 | "execution_count": null, 260 | "metadata": {}, 261 | "outputs": [], 262 | "source": [ 263 | "foo(3.0, 4.0)" 264 | ] 265 | }, 266 | { 267 | "cell_type": "markdown", 268 | "metadata": {}, 269 | "source": [ 270 | "We can also add a fallback, duck-typed method for `foo` that takes inputs of any type:" 271 | ] 272 | }, 273 | { 274 | "cell_type": "code", 275 | "execution_count": null, 276 | "metadata": {}, 277 | "outputs": [], 278 | "source": [ 279 | "foo(x, y) = println(\"I accept inputs of any type!\")" 280 | ] 281 | }, 282 | { 283 | "cell_type": "markdown", 284 | "metadata": {}, 285 | "source": [ 286 | "Given the methods we've already written for `foo` so far, this method will be called whenever we pass non-numbers to `foo`:" 287 | ] 288 | }, 289 | { 290 | "cell_type": "code", 291 | "execution_count": null, 292 | "metadata": {}, 293 | "outputs": [], 294 | "source": [ 295 | "v = rand(3)\n", 296 | "foo(v, v)" 297 | ] 298 | }, 299 | { 300 | "cell_type": "markdown", 301 | "metadata": { 302 | "collapsed": true 303 | }, 304 | "source": [ 305 | "### Exercises\n", 306 | "\n", 307 | "#### 9.1\n", 308 | "\n", 309 | "Extend the function `foo`, adding a method that takes only one input argument, which is of type `Bool`, and prints \"foo with one boolean!\"" 310 | ] 311 | }, 312 | { 313 | "cell_type": "code", 314 | "execution_count": null, 315 | "metadata": {}, 316 | "outputs": [], 317 | "source": [] 318 | }, 319 | { 320 | "cell_type": "markdown", 321 | "metadata": {}, 322 | "source": [ 323 | "#### 9.2\n", 324 | "\n", 325 | "Check that the method being dispatched when you execute \n", 326 | "```julia\n", 327 | "foo(true)\n", 328 | "```\n", 329 | "is the one you wrote." 330 | ] 331 | }, 332 | { 333 | "cell_type": "code", 334 | "execution_count": null, 335 | "metadata": {}, 336 | "outputs": [], 337 | "source": [] 338 | } 339 | ], 340 | "metadata": { 341 | "anaconda-cloud": {}, 342 | "kernelspec": { 343 | "display_name": "Julia 1.0.0", 344 | "language": "julia", 345 | "name": "julia-1.0" 346 | }, 347 | "language": "Julia", 348 | "language_info": { 349 | "file_extension": ".jl", 350 | "mimetype": "application/julia", 351 | "name": "julia", 352 | "version": "1.0.0" 353 | }, 354 | "toc": { 355 | "nav_menu": { 356 | "height": "119px", 357 | "width": "251px" 358 | }, 359 | "navigate_menu": true, 360 | "number_sections": true, 361 | "sideBar": true, 362 | "threshold": "2", 363 | "toc_cell": false, 364 | "toc_section_display": "block", 365 | "toc_window_display": false 366 | } 367 | }, 368 | "nbformat": 4, 369 | "nbformat_minor": 1 370 | } 371 | -------------------------------------------------------------------------------- /11.Basic_linear_algebra.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Basic linear algebra in Julia\n", 8 | "Author: Andreas Noack Jensen (MIT) (http://www.econ.ku.dk/phdstudent/noack/)\n", 9 | "(with edits from Jane Herriman)" 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "First let's define a random matrix" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "A = rand(1:4,3,3)" 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "Define a vector of ones" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": null, 38 | "metadata": {}, 39 | "outputs": [], 40 | "source": [ 41 | "x = fill(1.0, (3,)) # = fill(1.0, 3)" 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "Notice that $A$ has type Array{Int64,2} but $x$ has type Array{Float64,1}. Julia defines the aliases Vector{Type}=Array{Type,1} and Matrix{Type}=Array{Type,2}. \n", 49 | "\n", 50 | "Many of the basic operations are the same as in other languages\n", 51 | "#### Multiplication" 52 | ] 53 | }, 54 | { 55 | "cell_type": "code", 56 | "execution_count": null, 57 | "metadata": {}, 58 | "outputs": [], 59 | "source": [ 60 | "b = A*x" 61 | ] 62 | }, 63 | { 64 | "cell_type": "markdown", 65 | "metadata": {}, 66 | "source": [ 67 | "#### Transposition\n", 68 | "As in other languages `A'` is the conjugate transpose, or adjoint" 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": null, 74 | "metadata": {}, 75 | "outputs": [], 76 | "source": [ 77 | "A'" 78 | ] 79 | }, 80 | { 81 | "cell_type": "markdown", 82 | "metadata": {}, 83 | "source": [ 84 | "and we can get the transpose with" 85 | ] 86 | }, 87 | { 88 | "cell_type": "code", 89 | "execution_count": null, 90 | "metadata": {}, 91 | "outputs": [], 92 | "source": [ 93 | "transpose(A)" 94 | ] 95 | }, 96 | { 97 | "cell_type": "markdown", 98 | "metadata": {}, 99 | "source": [ 100 | "#### Transposed multiplication\n", 101 | "Julia allows us to write this without *" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": null, 107 | "metadata": {}, 108 | "outputs": [], 109 | "source": [ 110 | "A'A" 111 | ] 112 | }, 113 | { 114 | "cell_type": "markdown", 115 | "metadata": {}, 116 | "source": [ 117 | "#### Solving linear systems \n", 118 | "The problem $Ax=b$ for ***square*** $A$ is solved by the \\ function." 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": null, 124 | "metadata": {}, 125 | "outputs": [], 126 | "source": [ 127 | "A\\b" 128 | ] 129 | }, 130 | { 131 | "cell_type": "markdown", 132 | "metadata": {}, 133 | "source": [ 134 | "`A\\b` gives us the *least squares solution* if we have an overdetermined linear system (a \"tall\" matrix)" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": null, 140 | "metadata": {}, 141 | "outputs": [], 142 | "source": [ 143 | "Atall = rand(3, 2)" 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": null, 149 | "metadata": {}, 150 | "outputs": [], 151 | "source": [ 152 | "Atall\\b" 153 | ] 154 | }, 155 | { 156 | "cell_type": "markdown", 157 | "metadata": {}, 158 | "source": [ 159 | "and the *minimum norm least squares solution* if we have a rank-deficient least squares problem" 160 | ] 161 | }, 162 | { 163 | "cell_type": "code", 164 | "execution_count": null, 165 | "metadata": {}, 166 | "outputs": [], 167 | "source": [ 168 | "v = rand(3)\n", 169 | "rankdef = hcat(v, v)" 170 | ] 171 | }, 172 | { 173 | "cell_type": "code", 174 | "execution_count": null, 175 | "metadata": {}, 176 | "outputs": [], 177 | "source": [ 178 | "rankdef\\b" 179 | ] 180 | }, 181 | { 182 | "cell_type": "markdown", 183 | "metadata": {}, 184 | "source": [ 185 | "Julia also gives us the minimum norm solution when we have an underdetermined solution (a \"short\" matrix)" 186 | ] 187 | }, 188 | { 189 | "cell_type": "code", 190 | "execution_count": null, 191 | "metadata": {}, 192 | "outputs": [], 193 | "source": [ 194 | "bshort = rand(2)\n", 195 | "Ashort = rand(2, 3)" 196 | ] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": null, 201 | "metadata": {}, 202 | "outputs": [], 203 | "source": [ 204 | "Ashort\\bshort" 205 | ] 206 | }, 207 | { 208 | "cell_type": "markdown", 209 | "metadata": {}, 210 | "source": [ 211 | "# The LinearAlgebra library\n", 212 | "\n", 213 | "While much of linear algebra is available in Julia by default (as shown above), there's a standard library named `LinearAlgebra` that brings in many more relevant names and functions. In particular, it provides factorizations and some structured matrix types. As with all packages, you can bring these additional features into your session with a `using LinearAlgebra`." 214 | ] 215 | }, 216 | { 217 | "cell_type": "markdown", 218 | "metadata": {}, 219 | "source": [ 220 | "### Exercises\n", 221 | "\n", 222 | "#### 10.1 \n", 223 | "Take the inner product (or \"dot\" product) of a vector `v` with itself." 224 | ] 225 | }, 226 | { 227 | "cell_type": "code", 228 | "execution_count": null, 229 | "metadata": {}, 230 | "outputs": [], 231 | "source": [] 232 | }, 233 | { 234 | "cell_type": "markdown", 235 | "metadata": {}, 236 | "source": [ 237 | "#### 10.2 \n", 238 | "Take the outer product of a vector v with itself." 239 | ] 240 | }, 241 | { 242 | "cell_type": "code", 243 | "execution_count": null, 244 | "metadata": {}, 245 | "outputs": [], 246 | "source": [] 247 | } 248 | ], 249 | "metadata": { 250 | "kernelspec": { 251 | "display_name": "Julia 1.0.0", 252 | "language": "julia", 253 | "name": "julia-1.0" 254 | }, 255 | "language": "Julia", 256 | "language_info": { 257 | "file_extension": ".jl", 258 | "mimetype": "application/julia", 259 | "name": "julia", 260 | "version": "1.0.0" 261 | } 262 | }, 263 | "nbformat": 4, 264 | "nbformat_minor": 1 265 | } 266 | -------------------------------------------------------------------------------- /12.Factorizations_and_other_fun.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Factorizations and other fun\n", 8 | "Based on work by Andreas Noack\n", 9 | "\n", 10 | "## Outline\n", 11 | " - Factorizations\n", 12 | " - Special matrix structures\n", 13 | " - Generic linear algebra" 14 | ] 15 | }, 16 | { 17 | "cell_type": "markdown", 18 | "metadata": {}, 19 | "source": [ 20 | "Before we get started, let's set up a linear system and use `LinearAlgebra` to bring in the factorizations and special matrix structures." 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": null, 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "using LinearAlgebra\n", 30 | "A = rand(3, 3)\n", 31 | "x = fill(1, (3,))\n", 32 | "b = A * x" 33 | ] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "metadata": {}, 38 | "source": [ 39 | "## Factorizations\n", 40 | "\n", 41 | "#### LU factorizations\n", 42 | "In Julia we can perform an LU factorization\n", 43 | "```julia\n", 44 | "PA = LU\n", 45 | "``` \n", 46 | "where `P` is a permutation matrix, `L` is lower triangular unit diagonal and `U` is upper triangular, using `lufact`.\n", 47 | "\n", 48 | "Julia allows computing the LU factorization and defines a composite factorization type for storing it." 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": null, 54 | "metadata": {}, 55 | "outputs": [], 56 | "source": [ 57 | "Alu = lu(A)" 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": null, 63 | "metadata": {}, 64 | "outputs": [], 65 | "source": [ 66 | "typeof(Alu)" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "metadata": {}, 72 | "source": [ 73 | "The different parts of the factorization can be extracted by accessing their special properties" 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": null, 79 | "metadata": {}, 80 | "outputs": [], 81 | "source": [ 82 | "Alu.P" 83 | ] 84 | }, 85 | { 86 | "cell_type": "code", 87 | "execution_count": null, 88 | "metadata": {}, 89 | "outputs": [], 90 | "source": [ 91 | "Alu.L" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": null, 97 | "metadata": {}, 98 | "outputs": [], 99 | "source": [ 100 | "Alu.U" 101 | ] 102 | }, 103 | { 104 | "cell_type": "markdown", 105 | "metadata": {}, 106 | "source": [ 107 | "Julia can dispatch methods on factorization objects.\n", 108 | "\n", 109 | "For example, we can solve the linear system using either the original matrix or the factorization object." 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": null, 115 | "metadata": {}, 116 | "outputs": [], 117 | "source": [ 118 | "A\\b" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": null, 124 | "metadata": {}, 125 | "outputs": [], 126 | "source": [ 127 | "Alu\\b" 128 | ] 129 | }, 130 | { 131 | "cell_type": "markdown", 132 | "metadata": {}, 133 | "source": [ 134 | "Similarly, we can calculate the determinant of `A` using either `A` or the factorization object" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": null, 140 | "metadata": {}, 141 | "outputs": [], 142 | "source": [ 143 | "det(A) ≈ det(Alu)" 144 | ] 145 | }, 146 | { 147 | "cell_type": "markdown", 148 | "metadata": {}, 149 | "source": [ 150 | "#### QR factorizations\n", 151 | "\n", 152 | "In Julia we can perform a QR factorization\n", 153 | "```\n", 154 | "A=QR\n", 155 | "``` \n", 156 | "\n", 157 | "where `Q` is unitary/orthogonal and `R` is upper triangular, using `qrfact`. " 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": null, 163 | "metadata": {}, 164 | "outputs": [], 165 | "source": [ 166 | "Aqr = qr(A)" 167 | ] 168 | }, 169 | { 170 | "cell_type": "markdown", 171 | "metadata": {}, 172 | "source": [ 173 | "Similarly to the LU factorization, the matrices `Q` and `R` can be extracted from the QR factorization object via" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": null, 179 | "metadata": {}, 180 | "outputs": [], 181 | "source": [ 182 | "Aqr.Q" 183 | ] 184 | }, 185 | { 186 | "cell_type": "code", 187 | "execution_count": null, 188 | "metadata": {}, 189 | "outputs": [], 190 | "source": [ 191 | "Aqr.R" 192 | ] 193 | }, 194 | { 195 | "cell_type": "markdown", 196 | "metadata": {}, 197 | "source": [ 198 | "#### Eigendecompositions" 199 | ] 200 | }, 201 | { 202 | "cell_type": "markdown", 203 | "metadata": {}, 204 | "source": [ 205 | "The results from eigendecompositions, singular value decompositions, Hessenberg factorizations, and Schur decompositions are all stored in `Factorization` types.\n", 206 | "\n", 207 | "The eigendecomposition can be computed" 208 | ] 209 | }, 210 | { 211 | "cell_type": "code", 212 | "execution_count": null, 213 | "metadata": {}, 214 | "outputs": [], 215 | "source": [ 216 | "Asym = A + A'\n", 217 | "AsymEig = eigen(Asym)" 218 | ] 219 | }, 220 | { 221 | "cell_type": "markdown", 222 | "metadata": {}, 223 | "source": [ 224 | "The values and the vectors can be extracted from the Eigen type by special indexing" 225 | ] 226 | }, 227 | { 228 | "cell_type": "code", 229 | "execution_count": null, 230 | "metadata": {}, 231 | "outputs": [], 232 | "source": [ 233 | "AsymEig.values" 234 | ] 235 | }, 236 | { 237 | "cell_type": "code", 238 | "execution_count": null, 239 | "metadata": {}, 240 | "outputs": [], 241 | "source": [ 242 | "AsymEig.vectors" 243 | ] 244 | }, 245 | { 246 | "cell_type": "markdown", 247 | "metadata": {}, 248 | "source": [ 249 | "Once again, when the factorization is stored in a type, we can dispatch on it and write specialized methods that exploit the properties of the factorization, e.g. that $A^{-1}=(V\\Lambda V^{-1})^{-1}=V\\Lambda^{-1}V^{-1}$." 250 | ] 251 | }, 252 | { 253 | "cell_type": "code", 254 | "execution_count": null, 255 | "metadata": {}, 256 | "outputs": [], 257 | "source": [ 258 | "inv(AsymEig)*Asym" 259 | ] 260 | }, 261 | { 262 | "cell_type": "markdown", 263 | "metadata": {}, 264 | "source": [ 265 | "## Special matrix structures\n", 266 | "Matrix structure is very important in linear algebra. To see *how* important it is, let's work with a larger linear system" 267 | ] 268 | }, 269 | { 270 | "cell_type": "code", 271 | "execution_count": null, 272 | "metadata": {}, 273 | "outputs": [], 274 | "source": [ 275 | "n = 1000\n", 276 | "A = randn(n,n);" 277 | ] 278 | }, 279 | { 280 | "cell_type": "markdown", 281 | "metadata": {}, 282 | "source": [ 283 | "Julia can often infer special matrix structure" 284 | ] 285 | }, 286 | { 287 | "cell_type": "code", 288 | "execution_count": null, 289 | "metadata": {}, 290 | "outputs": [], 291 | "source": [ 292 | "Asym = A + A'\n", 293 | "issymmetric(Asym)" 294 | ] 295 | }, 296 | { 297 | "cell_type": "markdown", 298 | "metadata": {}, 299 | "source": [ 300 | "but sometimes floating point error might get in the way." 301 | ] 302 | }, 303 | { 304 | "cell_type": "code", 305 | "execution_count": null, 306 | "metadata": {}, 307 | "outputs": [], 308 | "source": [ 309 | "Asym_noisy = copy(Asym)\n", 310 | "Asym_noisy[1,2] += 5eps()" 311 | ] 312 | }, 313 | { 314 | "cell_type": "code", 315 | "execution_count": null, 316 | "metadata": {}, 317 | "outputs": [], 318 | "source": [ 319 | "issymmetric(Asym_noisy)" 320 | ] 321 | }, 322 | { 323 | "cell_type": "markdown", 324 | "metadata": {}, 325 | "source": [ 326 | "Luckily we can declare structure explicitly with, for example, `Diagonal`, `Triangular`, `Symmetric`, `Hermitian`, `Tridiagonal` and `SymTridiagonal`." 327 | ] 328 | }, 329 | { 330 | "cell_type": "code", 331 | "execution_count": null, 332 | "metadata": {}, 333 | "outputs": [], 334 | "source": [ 335 | "Asym_explicit = Symmetric(Asym_noisy);" 336 | ] 337 | }, 338 | { 339 | "cell_type": "markdown", 340 | "metadata": {}, 341 | "source": [ 342 | "Let's compare how long it takes Julia to compute the eigenvalues of `Asym`, `Asym_noisy`, and `Asym_explicit`" 343 | ] 344 | }, 345 | { 346 | "cell_type": "code", 347 | "execution_count": null, 348 | "metadata": {}, 349 | "outputs": [], 350 | "source": [ 351 | "@time eigvals(Asym);" 352 | ] 353 | }, 354 | { 355 | "cell_type": "code", 356 | "execution_count": null, 357 | "metadata": {}, 358 | "outputs": [], 359 | "source": [ 360 | "@time eigvals(Asym_noisy);" 361 | ] 362 | }, 363 | { 364 | "cell_type": "code", 365 | "execution_count": null, 366 | "metadata": {}, 367 | "outputs": [], 368 | "source": [ 369 | "@time eigvals(Asym_explicit);" 370 | ] 371 | }, 372 | { 373 | "cell_type": "markdown", 374 | "metadata": {}, 375 | "source": [ 376 | "In this example, using `Symmetric()` on `Asym_noisy` made our calculations about `5x` more efficient :)" 377 | ] 378 | }, 379 | { 380 | "cell_type": "markdown", 381 | "metadata": {}, 382 | "source": [ 383 | "#### A big problem\n", 384 | "Using the `Tridiagonal` and `SymTridiagonal` types to store tridiagonal matrices makes it possible to work with potentially very large tridiagonal problems. The following problem would not be possible to solve on a laptop if the matrix had to be stored as a (dense) `Matrix` type." 385 | ] 386 | }, 387 | { 388 | "cell_type": "code", 389 | "execution_count": null, 390 | "metadata": {}, 391 | "outputs": [], 392 | "source": [ 393 | "n = 1_000_000;\n", 394 | "A = SymTridiagonal(randn(n), randn(n-1));\n", 395 | "@time eigmax(A)" 396 | ] 397 | }, 398 | { 399 | "cell_type": "markdown", 400 | "metadata": {}, 401 | "source": [ 402 | "## Generic linear algebra\n", 403 | "The usual way of adding support for numerical linear algebra is by wrapping BLAS and LAPACK subroutines. For matrices with elements of `Float32`, `Float64`, `Complex{Float32}` or `Complex{Float64}` this is also what Julia does.\n", 404 | "\n", 405 | "However, Julia also supports generic linear algebra, allowing you to, for example, work with matrices and vectors of rational numbers." 406 | ] 407 | }, 408 | { 409 | "cell_type": "markdown", 410 | "metadata": {}, 411 | "source": [ 412 | "#### Rational numbers\n", 413 | "Julia has rational numbers built in. To construct a rational number, use double forward slashes:" 414 | ] 415 | }, 416 | { 417 | "cell_type": "code", 418 | "execution_count": null, 419 | "metadata": {}, 420 | "outputs": [], 421 | "source": [ 422 | "1//2" 423 | ] 424 | }, 425 | { 426 | "cell_type": "markdown", 427 | "metadata": {}, 428 | "source": [ 429 | "#### Example: Rational linear system of equations\n", 430 | "The following example shows how linear system of equations with rational elements can be solved without promoting to floating point element types. Overflow can easily become a problem when working with rational numbers so we use `BigInt`s." 431 | ] 432 | }, 433 | { 434 | "cell_type": "code", 435 | "execution_count": null, 436 | "metadata": {}, 437 | "outputs": [], 438 | "source": [ 439 | "Arational = Matrix{Rational{BigInt}}(rand(1:10, 3, 3))/10" 440 | ] 441 | }, 442 | { 443 | "cell_type": "code", 444 | "execution_count": null, 445 | "metadata": {}, 446 | "outputs": [], 447 | "source": [ 448 | "x = fill(1, 3)\n", 449 | "b = Arational*x" 450 | ] 451 | }, 452 | { 453 | "cell_type": "code", 454 | "execution_count": null, 455 | "metadata": {}, 456 | "outputs": [], 457 | "source": [ 458 | "Arational\\b" 459 | ] 460 | }, 461 | { 462 | "cell_type": "code", 463 | "execution_count": null, 464 | "metadata": {}, 465 | "outputs": [], 466 | "source": [ 467 | "lu(Arational)" 468 | ] 469 | }, 470 | { 471 | "cell_type": "markdown", 472 | "metadata": {}, 473 | "source": [ 474 | "### Exercises\n", 475 | "\n", 476 | "#### 11.1\n", 477 | "What are the eigenvalues of matrix A?\n", 478 | "\n", 479 | "```\n", 480 | "A =\n", 481 | "[\n", 482 | " 140 97 74 168 131\n", 483 | " 97 106 89 131 36\n", 484 | " 74 89 152 144 71\n", 485 | " 168 131 144 54 142\n", 486 | " 131 36 71 142 36\n", 487 | "]\n", 488 | "```" 489 | ] 490 | }, 491 | { 492 | "cell_type": "code", 493 | "execution_count": null, 494 | "metadata": {}, 495 | "outputs": [], 496 | "source": [] 497 | }, 498 | { 499 | "cell_type": "markdown", 500 | "metadata": {}, 501 | "source": [ 502 | "#### 11.2 \n", 503 | "Create a `Diagonal` matrix from the eigenvalues of `A`." 504 | ] 505 | }, 506 | { 507 | "cell_type": "code", 508 | "execution_count": null, 509 | "metadata": {}, 510 | "outputs": [], 511 | "source": [] 512 | }, 513 | { 514 | "cell_type": "markdown", 515 | "metadata": {}, 516 | "source": [ 517 | "#### 11.3 \n", 518 | "Create a `LowerTriangular` matrix from `A`." 519 | ] 520 | }, 521 | { 522 | "cell_type": "code", 523 | "execution_count": null, 524 | "metadata": {}, 525 | "outputs": [], 526 | "source": [] 527 | }, 528 | { 529 | "cell_type": "markdown", 530 | "metadata": {}, 531 | "source": [ 532 | "### Please let us know how we're doing!\n", 533 | "https://tinyurl.com/introJuliaFeedback" 534 | ] 535 | }, 536 | { 537 | "cell_type": "code", 538 | "execution_count": null, 539 | "metadata": {}, 540 | "outputs": [], 541 | "source": [] 542 | } 543 | ], 544 | "metadata": { 545 | "kernelspec": { 546 | "display_name": "Julia 1.0.0", 547 | "language": "julia", 548 | "name": "julia-1.0" 549 | }, 550 | "language": "Julia", 551 | "language_info": { 552 | "file_extension": ".jl", 553 | "mimetype": "application/julia", 554 | "name": "julia", 555 | "version": "1.0.0" 556 | } 557 | }, 558 | "nbformat": 4, 559 | "nbformat_minor": 1 560 | } 561 | -------------------------------------------------------------------------------- /LICENSE.md: -------------------------------------------------------------------------------- 1 | The contents of this directory are under The MIT License. 2 | 3 | Copyright (c) 2018: Julia Computing, Inc. 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: 6 | 7 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. 8 | 9 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 10 | -------------------------------------------------------------------------------- /es/ 1. Calentando motores.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Empezando\n", 8 | "\n", 9 | "Temas:\n", 10 | "1. Cómo conseguir documentación\n", 11 | "2. Cómo imprimir a pantalla\n", 12 | "3. Cómo asignar variables\n", 13 | "4. Cómo poner comentarios\n", 14 | "5. Sintáxis para matemáticas básicas" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "## Cómo conseguir documentación para funciones de Julia\n", 22 | "\n", 23 | "Para conseguir docs para funciones con las que uno no está familiarizado, pon un signo de interrogación antes. (¡También funciona en la terminal!)" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": null, 29 | "metadata": { 30 | "collapsed": false, 31 | "scrolled": false 32 | }, 33 | "outputs": [], 34 | "source": [ 35 | "?println" 36 | ] 37 | }, 38 | { 39 | "cell_type": "markdown", 40 | "metadata": {}, 41 | "source": [ 42 | "## Cómo imprimir\n", 43 | "\n", 44 | "En Julia usamos `println()` para imprimir texto a la pantalla. " 45 | ] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": null, 50 | "metadata": { 51 | "collapsed": false 52 | }, 53 | "outputs": [], 54 | "source": [ 55 | "println(\"¡Estoy emocionado por aprender Julia!\")" 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "Si es tu primera vez usando los notebooks, toma nota que la última línea de cada casilla es la que imprime cuando ejecutas la casilla." 63 | ] 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": null, 68 | "metadata": { 69 | "collapsed": true 70 | }, 71 | "outputs": [], 72 | "source": [ 73 | "123\n", 74 | "456" 75 | ] 76 | }, 77 | { 78 | "cell_type": "markdown", 79 | "metadata": {}, 80 | "source": [ 81 | "## Cómo asignar variables\n", 82 | "\n", 83 | "¡Sólo necesitas un nombre y un signo de igualdad!
\n", 84 | "Julia se encargará de saber el tipo de los datos por nosotros." 85 | ] 86 | }, 87 | { 88 | "cell_type": "code", 89 | "execution_count": null, 90 | "metadata": { 91 | "collapsed": true 92 | }, 93 | "outputs": [], 94 | "source": [ 95 | "my_answer = 42\n", 96 | "typeof(my_answer)" 97 | ] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "execution_count": null, 102 | "metadata": { 103 | "collapsed": true 104 | }, 105 | "outputs": [], 106 | "source": [ 107 | "my_pi = 3.14159\n", 108 | "typeof(my_pi)" 109 | ] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": null, 114 | "metadata": { 115 | "collapsed": true 116 | }, 117 | "outputs": [], 118 | "source": [ 119 | "my_name = \"Jane\"\n", 120 | "typeof(my_name)" 121 | ] 122 | }, 123 | { 124 | "cell_type": "markdown", 125 | "metadata": {}, 126 | "source": [ 127 | "After assigning a value to a variable, we can reassign a value of a different type to that variable without any issue." 128 | ] 129 | }, 130 | { 131 | "cell_type": "code", 132 | "execution_count": null, 133 | "metadata": { 134 | "collapsed": true 135 | }, 136 | "outputs": [], 137 | "source": [ 138 | "my_answer = my_name" 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": null, 144 | "metadata": { 145 | "collapsed": true 146 | }, 147 | "outputs": [], 148 | "source": [ 149 | "typeof(my_answer)" 150 | ] 151 | }, 152 | { 153 | "cell_type": "markdown", 154 | "metadata": {}, 155 | "source": [ 156 | "## Cómo comentar" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": null, 162 | "metadata": { 163 | "collapsed": true 164 | }, 165 | "outputs": [], 166 | "source": [ 167 | "# Puedes dejar un comentario en una sola línea usando la tecla de gato" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": null, 173 | "metadata": { 174 | "collapsed": true 175 | }, 176 | "outputs": [], 177 | "source": [ 178 | "#=\n", 179 | "\n", 180 | "Para comentarios de varias lineas,\n", 181 | "usa la secuencia de '#= =#' .\n", 182 | "\n", 183 | "=#" 184 | ] 185 | }, 186 | { 187 | "cell_type": "markdown", 188 | "metadata": {}, 189 | "source": [ 190 | "## Sintáxis para matemáticas básicas" 191 | ] 192 | }, 193 | { 194 | "cell_type": "code", 195 | "execution_count": null, 196 | "metadata": { 197 | "collapsed": true 198 | }, 199 | "outputs": [], 200 | "source": [ 201 | "suma = 3 + 7" 202 | ] 203 | }, 204 | { 205 | "cell_type": "code", 206 | "execution_count": null, 207 | "metadata": { 208 | "collapsed": true 209 | }, 210 | "outputs": [], 211 | "source": [ 212 | "resta = 10 - 3" 213 | ] 214 | }, 215 | { 216 | "cell_type": "code", 217 | "execution_count": null, 218 | "metadata": { 219 | "collapsed": true 220 | }, 221 | "outputs": [], 222 | "source": [ 223 | "producto = 20 * 5" 224 | ] 225 | }, 226 | { 227 | "cell_type": "code", 228 | "execution_count": null, 229 | "metadata": { 230 | "collapsed": true 231 | }, 232 | "outputs": [], 233 | "source": [ 234 | "cociente = 100 / 10" 235 | ] 236 | }, 237 | { 238 | "cell_type": "code", 239 | "execution_count": null, 240 | "metadata": { 241 | "collapsed": true 242 | }, 243 | "outputs": [], 244 | "source": [ 245 | "potencia = 10 ^ 2" 246 | ] 247 | }, 248 | { 249 | "cell_type": "code", 250 | "execution_count": null, 251 | "metadata": { 252 | "collapsed": true 253 | }, 254 | "outputs": [], 255 | "source": [ 256 | "módulo = 101 % 2" 257 | ] 258 | }, 259 | { 260 | "cell_type": "markdown", 261 | "metadata": {}, 262 | "source": [ 263 | "### Ejercicios\n", 264 | "\n", 265 | "1.1 Busca los docs para las funciones `convert` y `parse`." 266 | ] 267 | }, 268 | { 269 | "cell_type": "code", 270 | "execution_count": null, 271 | "metadata": { 272 | "collapsed": true 273 | }, 274 | "outputs": [], 275 | "source": [] 276 | }, 277 | { 278 | "cell_type": "markdown", 279 | "metadata": {}, 280 | "source": [ 281 | "1.2 Asigna `365` a una variable llamada `days`. Convierte `days` a un número flotante." 282 | ] 283 | }, 284 | { 285 | "cell_type": "code", 286 | "execution_count": null, 287 | "metadata": { 288 | "collapsed": true 289 | }, 290 | "outputs": [], 291 | "source": [] 292 | }, 293 | { 294 | "cell_type": "markdown", 295 | "metadata": {}, 296 | "source": [ 297 | "1.3 Fíjate que sucede cuando ejecutas\n", 298 | "\n", 299 | "```julia\n", 300 | "convert(Int64, '1')\n", 301 | "```\n", 302 | "y\n", 303 | "\n", 304 | "```julia\n", 305 | "parse(Int64, '1')\n", 306 | "```\n", 307 | "\n", 308 | "¿Cuál es la diferencia?" 309 | ] 310 | }, 311 | { 312 | "cell_type": "code", 313 | "execution_count": null, 314 | "metadata": { 315 | "collapsed": true 316 | }, 317 | "outputs": [], 318 | "source": [] 319 | } 320 | ], 321 | "metadata": { 322 | "kernelspec": { 323 | "display_name": "Julia 0.6.1", 324 | "language": "julia", 325 | "name": "julia-0.6" 326 | }, 327 | "language_info": { 328 | "file_extension": ".jl", 329 | "mimetype": "application/julia", 330 | "name": "julia", 331 | "version": "0.6.2" 332 | } 333 | }, 334 | "nbformat": 4, 335 | "nbformat_minor": 2 336 | } 337 | -------------------------------------------------------------------------------- /es/ 2. Cadenas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Cadenas (Strings)\n", 10 | "\n", 11 | "Temas:\n", 12 | "1. Cómo conseguir una cadena\n", 13 | "2. Interpolación de cadenas\n", 14 | "3. Concatenación de cadenas" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "## Cómo conseguir una cadena\n", 22 | "\n", 23 | "Enclose your characters in \" \" or \"\"\" \"\"\"!" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": null, 29 | "metadata": { 30 | "collapsed": true 31 | }, 32 | "outputs": [], 33 | "source": [ 34 | "s1 = \"Yo soy una cadena.\"" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": null, 40 | "metadata": { 41 | "collapsed": true 42 | }, 43 | "outputs": [], 44 | "source": [ 45 | "s2 = \"\"\"Yo también soy una cadena. \"\"\"" 46 | ] 47 | }, 48 | { 49 | "cell_type": "markdown", 50 | "metadata": {}, 51 | "source": [ 52 | "Existen algunas diferencias funcionales entre expresas cadenas con una sola y triple comillas.
\n", 53 | "Una diferencia es que en la segunda opción puedes usar comillas dentro de tu cadena." 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "execution_count": null, 59 | "metadata": { 60 | "collapsed": true 61 | }, 62 | "outputs": [], 63 | "source": [ 64 | "\"Aquí me sale un \"error\" porque es ambiguo dónde se acaba la cadena. \"" 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": null, 70 | "metadata": { 71 | "collapsed": true 72 | }, 73 | "outputs": [], 74 | "source": [ 75 | "\"\"\"Mira Mamá, sin \"errors\"!!! \"\"\"" 76 | ] 77 | }, 78 | { 79 | "cell_type": "markdown", 80 | "metadata": {}, 81 | "source": [ 82 | "Ojo, '' define a un caracter, ¡ NO una cadena!" 83 | ] 84 | }, 85 | { 86 | "cell_type": "code", 87 | "execution_count": null, 88 | "metadata": { 89 | "collapsed": true 90 | }, 91 | "outputs": [], 92 | "source": [ 93 | "typeof('a')" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": null, 99 | "metadata": { 100 | "collapsed": true 101 | }, 102 | "outputs": [], 103 | "source": [ 104 | "'Esto va a dar un error'" 105 | ] 106 | }, 107 | { 108 | "cell_type": "markdown", 109 | "metadata": {}, 110 | "source": [ 111 | "NOTA: En Julia todas las cadenas por default son del tipo UTF-8. Esto significa que podemos usar nuestros querídisimos acentos del habla hispana y nuestros signos de apertura de interrogación sin miedo a que nuestro código no corra en una máquina ajena. ¡Inténtalo!" 112 | ] 113 | }, 114 | { 115 | "cell_type": "markdown", 116 | "metadata": {}, 117 | "source": [ 118 | "## Interpolación de cadenas\n", 119 | "\n", 120 | "Podemos usar el símbolo $ para insertar variables existentes a una cadena y para evaluar expresiones en una cadena.
\n", 121 | "Abajo hay un ejemplo con información súmamente sensible." 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": null, 127 | "metadata": { 128 | "collapsed": true 129 | }, 130 | "outputs": [], 131 | "source": [ 132 | "nombre = \"Jane\"\n", 133 | "num_dedos = 10\n", 134 | "num_dedos_de_los_pies = 10\n", 135 | "\n", 136 | "println(\"Hola, me llamo $nombre.\")\n", 137 | "println(\"Yo tengo $num_dedos dedos y $num_dedos_de_los_pies. ¡Esos son $(num_dedos + num_dedos_de_los_pies) dígitos en total!!\")" 138 | ] 139 | }, 140 | { 141 | "cell_type": "markdown", 142 | "metadata": {}, 143 | "source": [ 144 | "## Concatenación de cadenas\n", 145 | "\n", 146 | "¡Abajo hay tres maneras de concatenar cadenas!

\n", 147 | "La primera es usando la función de `string()`
\n", 148 | "`string()` convierte no-cadenas en cadenas." 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": null, 154 | "metadata": { 155 | "collapsed": true 156 | }, 157 | "outputs": [], 158 | "source": [ 159 | "string(\"¿Cuántos gatos \", \"son demasiados?\")" 160 | ] 161 | }, 162 | { 163 | "cell_type": "code", 164 | "execution_count": null, 165 | "metadata": { 166 | "collapsed": true 167 | }, 168 | "outputs": [], 169 | "source": [ 170 | "string(\"No lo sé, pero \", 10, \" son muy pocos.\")" 171 | ] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "metadata": {}, 176 | "source": [ 177 | "We can also use `*` or string interpolation!" 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": null, 183 | "metadata": { 184 | "collapsed": true 185 | }, 186 | "outputs": [], 187 | "source": [ 188 | "s3 = \"¿Cuántos gatos \";\n", 189 | "s4 = \"son demasiados?\";" 190 | ] 191 | }, 192 | { 193 | "cell_type": "code", 194 | "execution_count": null, 195 | "metadata": { 196 | "collapsed": true 197 | }, 198 | "outputs": [], 199 | "source": [ 200 | "s3*s4" 201 | ] 202 | }, 203 | { 204 | "cell_type": "code", 205 | "execution_count": null, 206 | "metadata": { 207 | "collapsed": true 208 | }, 209 | "outputs": [], 210 | "source": [ 211 | "\"$s3$s4\"" 212 | ] 213 | }, 214 | { 215 | "cell_type": "markdown", 216 | "metadata": {}, 217 | "source": [ 218 | "### Ejercicios\n", 219 | "\n", 220 | "2.1 Crea una cadena que diga \"hola\" 1000 veces." 221 | ] 222 | }, 223 | { 224 | "cell_type": "code", 225 | "execution_count": null, 226 | "metadata": { 227 | "collapsed": true 228 | }, 229 | "outputs": [], 230 | "source": [] 231 | }, 232 | { 233 | "cell_type": "markdown", 234 | "metadata": {}, 235 | "source": [ 236 | "2.2 Agrega dos números dentro de una cadena." 237 | ] 238 | }, 239 | { 240 | "cell_type": "code", 241 | "execution_count": null, 242 | "metadata": { 243 | "collapsed": true 244 | }, 245 | "outputs": [], 246 | "source": [] 247 | } 248 | ], 249 | "metadata": { 250 | "kernelspec": { 251 | "display_name": "Julia 0.6.1", 252 | "language": "julia", 253 | "name": "julia-0.6" 254 | }, 255 | "language_info": { 256 | "file_extension": ".jl", 257 | "mimetype": "application/julia", 258 | "name": "julia", 259 | "version": "0.6.2" 260 | } 261 | }, 262 | "nbformat": 4, 263 | "nbformat_minor": 2 264 | } 265 | -------------------------------------------------------------------------------- /es/ 4. Bucles.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Bucles\n", 10 | "\n", 11 | "Temas:\n", 12 | "1. bucles `while` \n", 13 | "2. bucles `for`\n", 14 | "
\n", 15 | "\n", 16 | "## bucles while\n", 17 | "\n", 18 | "La sintaxis para un `while` es\n", 19 | "\n", 20 | "```julia\n", 21 | "while *condición*\n", 22 | " *cuerpo de bucle*\n", 23 | "end\n", 24 | "```\n", 25 | "\n", 26 | "Por ejemplo, usaremos un `while` para contar o iterar sobre un arreglo." 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": null, 32 | "metadata": { 33 | "collapsed": true 34 | }, 35 | "outputs": [], 36 | "source": [ 37 | "n = 0\n", 38 | "while n < 10\n", 39 | " n += 1\n", 40 | " println(n)\n", 41 | "end" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": null, 47 | "metadata": { 48 | "collapsed": true 49 | }, 50 | "outputs": [], 51 | "source": [ 52 | "myfriends = [\"Ted\", \"Robyn\", \"Barney\", \"Lily\", \"Marshall\"]\n", 53 | "\n", 54 | "i = 1\n", 55 | "while i <= length(myfriends)\n", 56 | " friend = myfriends[i]\n", 57 | " println(\"Hola $friend, ¡gusto en verte!\")\n", 58 | " i += 1\n", 59 | "end" 60 | ] 61 | }, 62 | { 63 | "cell_type": "markdown", 64 | "metadata": {}, 65 | "source": [ 66 | "## bucles for\n", 67 | "\n", 68 | "La sintaxis para un bucle `for` es\n", 69 | "\n", 70 | "```julia\n", 71 | "for *var* in *iterable de bucle*\n", 72 | " *cuerpo de bucle*\n", 73 | "end\n", 74 | "```\n", 75 | "\n", 76 | "Podemos usar un bucle for para generar los datos anteriores" 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": null, 82 | "metadata": { 83 | "collapsed": true 84 | }, 85 | "outputs": [], 86 | "source": [ 87 | "for n in 1:10\n", 88 | " println(n)\n", 89 | "end" 90 | ] 91 | }, 92 | { 93 | "cell_type": "code", 94 | "execution_count": null, 95 | "metadata": { 96 | "collapsed": true 97 | }, 98 | "outputs": [], 99 | "source": [ 100 | "myfriends = [\"Ted\", \"Robyn\", \"Barney\", \"Lily\", \"Marshall\"]\n", 101 | "\n", 102 | "for friend in myfriends\n", 103 | " println(\"Hi $friend, it's great to see you!\")\n", 104 | "end" 105 | ] 106 | }, 107 | { 108 | "cell_type": "markdown", 109 | "metadata": {}, 110 | "source": [ 111 | "Nota: se puede reemplazar `in` con `=` ó `∈`." 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": null, 117 | "metadata": { 118 | "collapsed": true 119 | }, 120 | "outputs": [], 121 | "source": [ 122 | "for n = 1:10\n", 123 | " println(n)\n", 124 | "end" 125 | ] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": null, 130 | "metadata": { 131 | "collapsed": true 132 | }, 133 | "outputs": [], 134 | "source": [ 135 | "for n ∈ 1:10\n", 136 | " println(n)\n", 137 | "end" 138 | ] 139 | }, 140 | { 141 | "cell_type": "markdown", 142 | "metadata": {}, 143 | "source": [ 144 | "Ahora usemos bucles `for` para crear tablas de sumas donde el valor de cada entrada es la suma de los índices del renglón y la columna.
\n", 145 | "\n", 146 | "Primero, inicializamos el arreglo con puros 0s." 147 | ] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": null, 152 | "metadata": { 153 | "collapsed": true 154 | }, 155 | "outputs": [], 156 | "source": [ 157 | "m, n = 5, 5\n", 158 | "A = fill(0, (m, n))" 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": null, 164 | "metadata": { 165 | "collapsed": true 166 | }, 167 | "outputs": [], 168 | "source": [ 169 | "for i in 1:m\n", 170 | " for j in 1:n\n", 171 | " A[i, j] = i + j\n", 172 | " end\n", 173 | "end\n", 174 | "A" 175 | ] 176 | }, 177 | { 178 | "cell_type": "markdown", 179 | "metadata": {}, 180 | "source": [ 181 | "Aquí va un poquito de azúcar sintáctica para el bucle `for`" 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": null, 187 | "metadata": { 188 | "collapsed": true 189 | }, 190 | "outputs": [], 191 | "source": [ 192 | "B = fill(0, (m, n))" 193 | ] 194 | }, 195 | { 196 | "cell_type": "code", 197 | "execution_count": null, 198 | "metadata": { 199 | "collapsed": true 200 | }, 201 | "outputs": [], 202 | "source": [ 203 | "for i in 1:m, j in 1:n\n", 204 | " B[i, j] = i + j\n", 205 | "end\n", 206 | "B" 207 | ] 208 | }, 209 | { 210 | "cell_type": "markdown", 211 | "metadata": {}, 212 | "source": [ 213 | "La manera mas \"Juliana\" de crear esta tabla es por medio de un *array comprehension / comprehensión de arreglo*." 214 | ] 215 | }, 216 | { 217 | "cell_type": "code", 218 | "execution_count": null, 219 | "metadata": { 220 | "collapsed": true 221 | }, 222 | "outputs": [], 223 | "source": [ 224 | "C = [i + j for i in 1:m, j in 1:n]" 225 | ] 226 | }, 227 | { 228 | "cell_type": "markdown", 229 | "metadata": {}, 230 | "source": [ 231 | "En el próximo ejemplo, embebimos un arreglo de comprehensión en un bucle `for`, generando tablas de adición de tamaño creciente." 232 | ] 233 | }, 234 | { 235 | "cell_type": "code", 236 | "execution_count": null, 237 | "metadata": { 238 | "collapsed": true 239 | }, 240 | "outputs": [], 241 | "source": [ 242 | "for n in 1:10\n", 243 | " A = [i + j for i in 1:n, j in 1:n]\n", 244 | " display(A)\n", 245 | "end" 246 | ] 247 | }, 248 | { 249 | "cell_type": "markdown", 250 | "metadata": {}, 251 | "source": [ 252 | "### Ejercicios\n", 253 | "\n", 254 | "4.1 Crea un diccionario `squares`, que tiene llaves de valores de 1 a 100. El valor asociado a cada llave es el cuadrado de la llave. Guarda los valores asociados a las llaves pares como enteros y las impares como cadenas. Por ejemplo,\n", 255 | "\n", 256 | "```julia\n", 257 | "squares[10] == 100\n", 258 | "squares[11] == \"121\"\n", 259 | "```\n", 260 | "\n", 261 | "(¡No necesitas condicionales para esto!)" 262 | ] 263 | }, 264 | { 265 | "cell_type": "code", 266 | "execution_count": null, 267 | "metadata": { 268 | "collapsed": true 269 | }, 270 | "outputs": [], 271 | "source": [] 272 | }, 273 | { 274 | "cell_type": "markdown", 275 | "metadata": { 276 | "collapsed": true 277 | }, 278 | "source": [ 279 | "4.2 Usa `fill` para crea una matriz de `10x10` de solo `0`'s. Pobla las primeras 10 entradas con el índice de esa entrada. ¿Julia usa el orden de primero columna o primero renglón? (O sea, ¿el \"segundo\" elemento es el de la primera columna en el primer renglón, ó es el de el primer renglón en la segunda columna?)" 280 | ] 281 | }, 282 | { 283 | "cell_type": "code", 284 | "execution_count": null, 285 | "metadata": { 286 | "collapsed": true 287 | }, 288 | "outputs": [], 289 | "source": [] 290 | } 291 | ], 292 | "metadata": { 293 | "kernelspec": { 294 | "display_name": "Julia 0.6.1", 295 | "language": "julia", 296 | "name": "julia-0.6" 297 | }, 298 | "language_info": { 299 | "file_extension": ".jl", 300 | "mimetype": "application/julia", 301 | "name": "julia", 302 | "version": "0.6.2" 303 | } 304 | }, 305 | "nbformat": 4, 306 | "nbformat_minor": 2 307 | } 308 | -------------------------------------------------------------------------------- /es/ 5. Condicionales.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Condicionales\n", 10 | "\n", 11 | "En Julia, la sintaxis\n", 12 | "\n", 13 | "```julia\n", 14 | "if *condición 1*\n", 15 | " *opción 1*\n", 16 | "elseif *condición 2*\n", 17 | " *opción 2*\n", 18 | "else\n", 19 | " *opción 3*\n", 20 | "end\n", 21 | "```\n", 22 | "\n", 23 | "Nos permite eventualmente evaluar una de nuestras opciones.\n", 24 | "

\n", 25 | "Por ejemplo, tal vez queremos implementar la prueba de FizzBuzz: Dado un número N, imprime \"Fizz\" si N es divisible entre 3, \"Buzz\" si N es divisible entre 5, y \"FizzBuzz\" si N es divisible entre ambos 3 y 5. En cualquier otro caso, imprimo el número mismo." 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": null, 31 | "metadata": { 32 | "collapsed": true 33 | }, 34 | "outputs": [], 35 | "source": [ 36 | "N = " 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": null, 42 | "metadata": { 43 | "collapsed": true 44 | }, 45 | "outputs": [], 46 | "source": [ 47 | "if (N % 3 == 0) & (N % 5 == 0)\n", 48 | " println(\"FizzBuzz\")\n", 49 | "elseif N % 3 == 0\n", 50 | " println(\"Fizz\")\n", 51 | "elseif N % 5 == 0\n", 52 | " println(\"Buzz\")\n", 53 | "else\n", 54 | " println(N)\n", 55 | "end" 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "Ahora digamos que queremos regresar el mayor número de ambos. Escoge tus propios x y y" 63 | ] 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": null, 68 | "metadata": { 69 | "collapsed": true 70 | }, 71 | "outputs": [], 72 | "source": [ 73 | "x = \n", 74 | "y = " 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": null, 80 | "metadata": { 81 | "collapsed": true 82 | }, 83 | "outputs": [], 84 | "source": [ 85 | "if x > y\n", 86 | " x\n", 87 | "else\n", 88 | " y\n", 89 | "end" 90 | ] 91 | }, 92 | { 93 | "cell_type": "markdown", 94 | "metadata": {}, 95 | "source": [ 96 | "Para el último bloque, podemos usar el operador ternario, con la sintaxis\n", 97 | "\n", 98 | "```julia\n", 99 | "a ? b : c\n", 100 | "```\n", 101 | "\n", 102 | "que equivale a\n", 103 | "\n", 104 | "```julia\n", 105 | "if a\n", 106 | " b\n", 107 | "else\n", 108 | " c\n", 109 | "end\n", 110 | "```" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": null, 116 | "metadata": { 117 | "collapsed": true 118 | }, 119 | "outputs": [], 120 | "source": [ 121 | "(x > y) ? x : y" 122 | ] 123 | }, 124 | { 125 | "cell_type": "markdown", 126 | "metadata": {}, 127 | "source": [ 128 | "Un truco relacionado es la evaluación de corto-circuito \n", 129 | "\n", 130 | "```julia\n", 131 | "a && b\n", 132 | "```" 133 | ] 134 | }, 135 | { 136 | "cell_type": "code", 137 | "execution_count": null, 138 | "metadata": { 139 | "collapsed": true 140 | }, 141 | "outputs": [], 142 | "source": [ 143 | "(x > y) && println(x)" 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": null, 149 | "metadata": { 150 | "collapsed": true 151 | }, 152 | "outputs": [], 153 | "source": [ 154 | "(x < y) && println(y)" 155 | ] 156 | }, 157 | { 158 | "cell_type": "markdown", 159 | "metadata": {}, 160 | "source": [ 161 | "Cuando escribimos `a && b`, `b` se ejecuta sólo si `a` se evalúa a `true`.\n", 162 | "
\n", 163 | "Si `a` se evalúa a `false`, la expresión `a && b` regresa `false`" 164 | ] 165 | }, 166 | { 167 | "cell_type": "markdown", 168 | "metadata": { 169 | "collapsed": true 170 | }, 171 | "source": [ 172 | "### Ejercicios\n", 173 | "\n", 174 | "5.1 Reescribe FizzBuzz sin usar `elseif`." 175 | ] 176 | }, 177 | { 178 | "cell_type": "code", 179 | "execution_count": null, 180 | "metadata": { 181 | "collapsed": true 182 | }, 183 | "outputs": [], 184 | "source": [] 185 | }, 186 | { 187 | "cell_type": "markdown", 188 | "metadata": {}, 189 | "source": [ 190 | "5.2 Reescribe FizzBuzz usando el operador ternario." 191 | ] 192 | }, 193 | { 194 | "cell_type": "code", 195 | "execution_count": null, 196 | "metadata": { 197 | "collapsed": true 198 | }, 199 | "outputs": [], 200 | "source": [] 201 | } 202 | ], 203 | "metadata": { 204 | "kernelspec": { 205 | "display_name": "Julia 0.6.1", 206 | "language": "julia", 207 | "name": "julia-0.6" 208 | }, 209 | "language_info": { 210 | "file_extension": ".jl", 211 | "mimetype": "application/julia", 212 | "name": "julia", 213 | "version": "0.6.2" 214 | } 215 | }, 216 | "nbformat": 4, 217 | "nbformat_minor": 2 218 | } 219 | -------------------------------------------------------------------------------- /es/ 6. Funciones.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Funciones\n", 8 | "\n", 9 | "Temas:\n", 10 | "1. Cómo declara una función\n", 11 | "2. Duck-typing en Julia\n", 12 | "3. Funciones mutantes vs. no-mutantes\n", 13 | "4. Broadcasting" 14 | ] 15 | }, 16 | { 17 | "cell_type": "markdown", 18 | "metadata": {}, 19 | "source": [ 20 | "## Cómo declarar una función\n", 21 | "Julia nos permite definir una función de varias maneras. La primera requiere de las palabras reservadas `function` y `end`" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": null, 27 | "metadata": { 28 | "collapsed": false 29 | }, 30 | "outputs": [], 31 | "source": [ 32 | "function sayhi(name)\n", 33 | " println(\"Hi $name, it's great to see you!\")\n", 34 | "end" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": null, 40 | "metadata": { 41 | "collapsed": false 42 | }, 43 | "outputs": [], 44 | "source": [ 45 | "function f(x)\n", 46 | " x^2\n", 47 | "end" 48 | ] 49 | }, 50 | { 51 | "cell_type": "markdown", 52 | "metadata": {}, 53 | "source": [ 54 | "Y las podemos llamar así" 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": null, 60 | "metadata": { 61 | "collapsed": false 62 | }, 63 | "outputs": [], 64 | "source": [ 65 | "sayhi(\"C-3PO\")" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": null, 71 | "metadata": { 72 | "collapsed": false 73 | }, 74 | "outputs": [], 75 | "source": [ 76 | "f(42)" 77 | ] 78 | }, 79 | { 80 | "cell_type": "markdown", 81 | "metadata": {}, 82 | "source": [ 83 | "Alternativamente, las podemos declarar en una sóla línea" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": null, 89 | "metadata": { 90 | "collapsed": false 91 | }, 92 | "outputs": [], 93 | "source": [ 94 | "sayhi2(name) = println(\"Hi $name, it's great to see you!\")" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": null, 100 | "metadata": { 101 | "collapsed": false 102 | }, 103 | "outputs": [], 104 | "source": [ 105 | "f2(x) = x^2" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": null, 111 | "metadata": { 112 | "collapsed": false 113 | }, 114 | "outputs": [], 115 | "source": [ 116 | "sayhi2(\"R2D2\")" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": null, 122 | "metadata": { 123 | "collapsed": false 124 | }, 125 | "outputs": [], 126 | "source": [ 127 | "f2(42)" 128 | ] 129 | }, 130 | { 131 | "cell_type": "markdown", 132 | "metadata": {}, 133 | "source": [ 134 | "Finalmente, pudimos declararlas como funciones \"anónimas\"" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": null, 140 | "metadata": { 141 | "collapsed": false 142 | }, 143 | "outputs": [], 144 | "source": [ 145 | "sayhi3 = name -> println(\"Hi $name, it's great to see you!\")" 146 | ] 147 | }, 148 | { 149 | "cell_type": "code", 150 | "execution_count": null, 151 | "metadata": { 152 | "collapsed": false 153 | }, 154 | "outputs": [], 155 | "source": [ 156 | "f3 = x -> x^2" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": null, 162 | "metadata": { 163 | "collapsed": false 164 | }, 165 | "outputs": [], 166 | "source": [ 167 | "sayhi3(\"Chewbacca\")" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": null, 173 | "metadata": { 174 | "collapsed": false 175 | }, 176 | "outputs": [], 177 | "source": [ 178 | "f3(42)" 179 | ] 180 | }, 181 | { 182 | "cell_type": "markdown", 183 | "metadata": {}, 184 | "source": [ 185 | "## Duck-typing en Julia\n", 186 | "*\"If it quacks like a duck, it's a duck.\"* \n", 187 | "*\"Si suena como pato, es un pato\"*\n", 188 | "

\n", 189 | "En Julia, las funciones operaran con el cualquier valor que haga sentido.

\n", 190 | "Por ejemplo, `sayhi` funciona con el nombre de este personaje de tele, escrito como entero..." 191 | ] 192 | }, 193 | { 194 | "cell_type": "code", 195 | "execution_count": null, 196 | "metadata": { 197 | "collapsed": false 198 | }, 199 | "outputs": [], 200 | "source": [ 201 | "sayhi(55595472)" 202 | ] 203 | }, 204 | { 205 | "cell_type": "markdown", 206 | "metadata": {}, 207 | "source": [ 208 | "Y `f` va a funcionar en una matriz." 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": null, 214 | "metadata": { 215 | "collapsed": false 216 | }, 217 | "outputs": [], 218 | "source": [ 219 | "A = rand(3, 3)\n", 220 | "A" 221 | ] 222 | }, 223 | { 224 | "cell_type": "code", 225 | "execution_count": null, 226 | "metadata": { 227 | "collapsed": false 228 | }, 229 | "outputs": [], 230 | "source": [ 231 | "f(A)" 232 | ] 233 | }, 234 | { 235 | "cell_type": "markdown", 236 | "metadata": {}, 237 | "source": [ 238 | "`f` funcionará con \"hi\" porque `*` para inputs de cadenas como concatenación." 239 | ] 240 | }, 241 | { 242 | "cell_type": "code", 243 | "execution_count": null, 244 | "metadata": { 245 | "collapsed": false 246 | }, 247 | "outputs": [], 248 | "source": [ 249 | "f(\"hi\")" 250 | ] 251 | }, 252 | { 253 | "cell_type": "markdown", 254 | "metadata": {}, 255 | "source": [ 256 | "Por el otro lado, `f` no funcionará sobre un vector. A diferencia de `A^2`, la cual es una operación bien definida, el signifiado de `v^2` para un vector, `v`, es ambigua. " 257 | ] 258 | }, 259 | { 260 | "cell_type": "code", 261 | "execution_count": null, 262 | "metadata": { 263 | "collapsed": false 264 | }, 265 | "outputs": [], 266 | "source": [ 267 | "v = rand(3)" 268 | ] 269 | }, 270 | { 271 | "cell_type": "code", 272 | "execution_count": null, 273 | "metadata": { 274 | "collapsed": false 275 | }, 276 | "outputs": [], 277 | "source": [ 278 | "f(v)" 279 | ] 280 | }, 281 | { 282 | "cell_type": "markdown", 283 | "metadata": { 284 | "collapsed": true 285 | }, 286 | "source": [ 287 | "## Funciones mutantes vs no-mutantes\n", 288 | "\n", 289 | "Por convención, funciones seguidas por un `!` alteran, o bien mutan, sus contenidos y las que carecen de un `!` no lo hacen.\n", 290 | "\n", 291 | "Por ejemplo, `sort` y `sort!`.\n" 292 | ] 293 | }, 294 | { 295 | "cell_type": "code", 296 | "execution_count": null, 297 | "metadata": { 298 | "collapsed": false 299 | }, 300 | "outputs": [], 301 | "source": [ 302 | "v = [3, 5, 2]" 303 | ] 304 | }, 305 | { 306 | "cell_type": "code", 307 | "execution_count": null, 308 | "metadata": { 309 | "collapsed": false 310 | }, 311 | "outputs": [], 312 | "source": [ 313 | "sort(v)" 314 | ] 315 | }, 316 | { 317 | "cell_type": "code", 318 | "execution_count": null, 319 | "metadata": { 320 | "collapsed": false 321 | }, 322 | "outputs": [], 323 | "source": [ 324 | "v" 325 | ] 326 | }, 327 | { 328 | "cell_type": "markdown", 329 | "metadata": {}, 330 | "source": [ 331 | "`sort(v)` regresa el arreglo ordenado de `v`, pero `v` no cambia.

\n", 332 | "\n", 333 | "Por otro lado, si corremos `sort!(v)`, el contenido del arreglo es ordenado dentro de `v`." 334 | ] 335 | }, 336 | { 337 | "cell_type": "code", 338 | "execution_count": null, 339 | "metadata": { 340 | "collapsed": false 341 | }, 342 | "outputs": [], 343 | "source": [ 344 | "sort!(v)" 345 | ] 346 | }, 347 | { 348 | "cell_type": "code", 349 | "execution_count": null, 350 | "metadata": { 351 | "collapsed": false 352 | }, 353 | "outputs": [], 354 | "source": [ 355 | "v" 356 | ] 357 | }, 358 | { 359 | "cell_type": "markdown", 360 | "metadata": {}, 361 | "source": [ 362 | "## Broadcasting\n", 363 | "\n", 364 | "Si ponemos `.` entre el nombre de la funcion y su lista de argumento,
\n", 365 | "le estamos diciendo a la función que se \"difunda\"/haga broadcasting sobre los elementos del input.
\n", 366 | "\n", 367 | "Primero veamos la diferencia entre `f()` y `f.()`.
\n", 368 | "\n", 369 | "Primero definimos una nueva matriz `A` que hará la diferencia fácil de observar" 370 | ] 371 | }, 372 | { 373 | "cell_type": "code", 374 | "execution_count": null, 375 | "metadata": { 376 | "collapsed": false 377 | }, 378 | "outputs": [], 379 | "source": [ 380 | "A = [i + 3*j for j in 0:2, i in 1:3]" 381 | ] 382 | }, 383 | { 384 | "cell_type": "code", 385 | "execution_count": null, 386 | "metadata": { 387 | "collapsed": false 388 | }, 389 | "outputs": [], 390 | "source": [ 391 | "f(A)" 392 | ] 393 | }, 394 | { 395 | "cell_type": "markdown", 396 | "metadata": {}, 397 | "source": [ 398 | "Cómo se vio antes, para una matriz, `A`,\n", 399 | "```\n", 400 | "f(A) = A^2 = A * A\n", 401 | "``` \n", 402 | "\n", 403 | "`f.(A)` por el otro lado va a regresar un objeto que contiene el cuadrado de `A[i, j]` en su entrada correspondiente." 404 | ] 405 | }, 406 | { 407 | "cell_type": "code", 408 | "execution_count": null, 409 | "metadata": { 410 | "collapsed": false 411 | }, 412 | "outputs": [], 413 | "source": [ 414 | "B = f.(A)" 415 | ] 416 | }, 417 | { 418 | "cell_type": "code", 419 | "execution_count": null, 420 | "metadata": { 421 | "collapsed": false 422 | }, 423 | "outputs": [], 424 | "source": [ 425 | "A[2, 2]" 426 | ] 427 | }, 428 | { 429 | "cell_type": "code", 430 | "execution_count": null, 431 | "metadata": { 432 | "collapsed": false 433 | }, 434 | "outputs": [], 435 | "source": [ 436 | "A[2, 2]^2" 437 | ] 438 | }, 439 | { 440 | "cell_type": "code", 441 | "execution_count": null, 442 | "metadata": { 443 | "collapsed": false 444 | }, 445 | "outputs": [], 446 | "source": [ 447 | "B[2, 2]" 448 | ] 449 | }, 450 | { 451 | "cell_type": "markdown", 452 | "metadata": {}, 453 | "source": [ 454 | "Esto significa que para `v`, `f.(v)` está definido, pero no para `f(v)` :" 455 | ] 456 | }, 457 | { 458 | "cell_type": "code", 459 | "execution_count": null, 460 | "metadata": { 461 | "collapsed": false 462 | }, 463 | "outputs": [], 464 | "source": [ 465 | "v = [1, 2, 3]" 466 | ] 467 | }, 468 | { 469 | "cell_type": "code", 470 | "execution_count": null, 471 | "metadata": { 472 | "collapsed": false 473 | }, 474 | "outputs": [], 475 | "source": [ 476 | "f.(v)" 477 | ] 478 | }, 479 | { 480 | "cell_type": "markdown", 481 | "metadata": { 482 | "collapsed": true 483 | }, 484 | "source": [ 485 | "### Ejercicios\n", 486 | "\n", 487 | "6.1 En vez de broadcastear `f` sobre `v`, pudimos haber hecho `v .^ 2`.\n", 488 | "\n", 489 | "Sin declarar una nueva funcion, agrega 1 a cada elemento de una matriz de `3x3` llena de `0`'s." 490 | ] 491 | }, 492 | { 493 | "cell_type": "code", 494 | "execution_count": null, 495 | "metadata": { 496 | "collapsed": true 497 | }, 498 | "outputs": [], 499 | "source": [] 500 | }, 501 | { 502 | "cell_type": "markdown", 503 | "metadata": { 504 | "collapsed": true 505 | }, 506 | "source": [] 507 | }, 508 | { 509 | "cell_type": "code", 510 | "execution_count": null, 511 | "metadata": { 512 | "collapsed": true 513 | }, 514 | "outputs": [], 515 | "source": [] 516 | }, 517 | { 518 | "cell_type": "markdown", 519 | "metadata": { 520 | "collapsed": true 521 | }, 522 | "source": [ 523 | "6.3 Una cifra de César recorre cada letra un número determinado de plazas más adelante en el abecedario. Un corrimiento, o shift, de 1 manda \"A\" a \"B\". Escribe una función llamada `cesar` que toma una cadena como input y un corrimiento y regresa una cadena desencriptada tal que obtengas\n", 524 | "\n", 525 | "```julia\n", 526 | "cesar(\"abc\", 1)\n", 527 | "\"bcd\"\n", 528 | "\n", 529 | "cesar(\"hello\", 4)\n", 530 | "\"lipps\"\n", 531 | "```" 532 | ] 533 | }, 534 | { 535 | "cell_type": "code", 536 | "execution_count": null, 537 | "metadata": { 538 | "collapsed": true 539 | }, 540 | "outputs": [], 541 | "source": [] 542 | } 543 | ], 544 | "metadata": { 545 | "kernelspec": { 546 | "display_name": "Julia 0.6.1", 547 | "language": "julia", 548 | "name": "julia-0.6" 549 | }, 550 | "language_info": { 551 | "file_extension": ".jl", 552 | "mimetype": "application/julia", 553 | "name": "julia", 554 | "version": "0.6.2" 555 | } 556 | }, 557 | "nbformat": 4, 558 | "nbformat_minor": 2 559 | } 560 | -------------------------------------------------------------------------------- /es/ 7. Paquetes.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Paquetes\n", 10 | "\n", 11 | "Julia tiene màs de 1686 paquetes registrados, conformando una gran parte del ecosistema de Julia.\n", 12 | "\n", 13 | "Para ver todos los paquetes, visita\n", 14 | "\n", 15 | "https://pkg.julialang.org/\n", 16 | "\n", 17 | "o bien\n", 18 | "\n", 19 | "https://juliaobserver.com/\n", 20 | "\n", 21 | "Ahora vamos a aprender a usarlos" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": {}, 27 | "source": [ 28 | "La primera vez que quieres usar un paquete en Julia, hay que agregarlo" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": 1, 34 | "metadata": { 35 | "collapsed": true 36 | }, 37 | "outputs": [], 38 | "source": [ 39 | "#Pkg.add(\"Example\")" 40 | ] 41 | }, 42 | { 43 | "cell_type": "markdown", 44 | "metadata": {}, 45 | "source": [ 46 | "Cada vez que usas Julia (empezar una nueva sesión en el REPL, abrir un notebook por primera vez, por ejemplo), tienes que cargar el paquete usando la palabra reservada `using`" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": null, 52 | "metadata": { 53 | "collapsed": true 54 | }, 55 | "outputs": [], 56 | "source": [ 57 | "using Example" 58 | ] 59 | }, 60 | { 61 | "cell_type": "markdown", 62 | "metadata": {}, 63 | "source": [ 64 | "En el código fuente de `Example.jl` en\n", 65 | "\n", 66 | "https://github.com/JuliaLang/Example.jl/blob/master/src/Example.jl\n", 67 | "\n", 68 | "Vemos una función declarada como \n", 69 | "\n", 70 | "```\n", 71 | "hello(who::String) = \"Hello, $who\"\n", 72 | "```\n", 73 | "\n", 74 | "Si cargamos `Example`, debemos poder llamar `hello`" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": null, 80 | "metadata": { 81 | "collapsed": true 82 | }, 83 | "outputs": [], 84 | "source": [ 85 | "hello(\"it's me. I was wondering if after all these years you'd like to meet.\")" 86 | ] 87 | }, 88 | { 89 | "cell_type": "markdown", 90 | "metadata": {}, 91 | "source": [ 92 | "Ahora vamos a jugar con el paquete de Colors" 93 | ] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "execution_count": null, 98 | "metadata": { 99 | "collapsed": true 100 | }, 101 | "outputs": [], 102 | "source": [ 103 | "#Pkg.add(\"Colors\")" 104 | ] 105 | }, 106 | { 107 | "cell_type": "code", 108 | "execution_count": null, 109 | "metadata": { 110 | "collapsed": true 111 | }, 112 | "outputs": [], 113 | "source": [ 114 | "using Colors" 115 | ] 116 | }, 117 | { 118 | "cell_type": "markdown", 119 | "metadata": {}, 120 | "source": [ 121 | "Creemos una bandeja de 100 colores" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": null, 127 | "metadata": { 128 | "collapsed": true 129 | }, 130 | "outputs": [], 131 | "source": [ 132 | "bandeja = distinguishable_colors(100)" 133 | ] 134 | }, 135 | { 136 | "cell_type": "markdown", 137 | "metadata": {}, 138 | "source": [ 139 | "y podemos crear una matriz colorida aleatoriamente con rand" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": null, 145 | "metadata": { 146 | "collapsed": true 147 | }, 148 | "outputs": [], 149 | "source": [ 150 | "rand(bandeja, 3, 3)" 151 | ] 152 | }, 153 | { 154 | "cell_type": "markdown", 155 | "metadata": {}, 156 | "source": [ 157 | "En el próximo notebook, vamos a usar un nuevo paquete para graficar datos" 158 | ] 159 | }, 160 | { 161 | "cell_type": "markdown", 162 | "metadata": {}, 163 | "source": [ 164 | "### Ejercicios\n", 165 | "\n", 166 | "7.1 Usa el paquete de (código fuente en https://github.com/JuliaMath/Primes.jl) para encontrar el número primer más grande menor a 1,000,000" 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": null, 172 | "metadata": { 173 | "collapsed": true 174 | }, 175 | "outputs": [], 176 | "source": [] 177 | } 178 | ], 179 | "metadata": { 180 | "kernelspec": { 181 | "display_name": "Julia 0.6.1", 182 | "language": "julia", 183 | "name": "julia-0.6" 184 | }, 185 | "language_info": { 186 | "file_extension": ".jl", 187 | "mimetype": "application/julia", 188 | "name": "julia", 189 | "version": "0.6.2" 190 | } 191 | }, 192 | "nbformat": 4, 193 | "nbformat_minor": 2 194 | } 195 | -------------------------------------------------------------------------------- /es/ 8. Graficas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Plotting / Gráficas\n", 8 | "\n", 9 | "## Introducción\n", 10 | "\n", 11 | "Hay muchas manera de graficar en Julia (además de usar PyPlot).
\n", 12 | "\n", 13 | "Aquí veremos como usar `Plots.jl`." 14 | ] 15 | }, 16 | { 17 | "cell_type": "code", 18 | "execution_count": null, 19 | "metadata": { 20 | "collapsed": true 21 | }, 22 | "outputs": [], 23 | "source": [ 24 | "#Pkg.add(\"Plots\")\n", 25 | "using Plots" 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "Una de las ventajas de `Plots.jl` Es que permite cambiar los backends sin costo alguno. En este notebook, vamos a intentar usar `gr()` y `plotlyjs()` como backends.
\n", 33 | "\n", 34 | "Primero vamos a generar datos artificiales para graficar" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": null, 40 | "metadata": { 41 | "collapsed": true 42 | }, 43 | "outputs": [], 44 | "source": [ 45 | "x = -3:0.1:3\n", 46 | "f(x) = x^2\n", 47 | "\n", 48 | "y = f.(x)" 49 | ] 50 | }, 51 | { 52 | "cell_type": "markdown", 53 | "metadata": {}, 54 | "source": [ 55 | "**Carguemos el backend de GR**" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": null, 61 | "metadata": { 62 | "collapsed": true 63 | }, 64 | "outputs": [], 65 | "source": [ 66 | "gr()" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": null, 72 | "metadata": { 73 | "collapsed": true 74 | }, 75 | "outputs": [], 76 | "source": [ 77 | "plot(x, y, label=\"linea\") \n", 78 | "scatter!(x, y, label=\"puntos\") " 79 | ] 80 | }, 81 | { 82 | "cell_type": "markdown", 83 | "metadata": {}, 84 | "source": [ 85 | "El `!` al final de `scatter!` indica que sea una función mutante, indicando que los puntos se van a agregar a la gráfica preexistente.\n", 86 | "\n", 87 | "Por contraste, en vez de usar `scatter!`, usa `scatter` para ver como funciona." 88 | ] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "metadata": {}, 93 | "source": [ 94 | "**Sin cambiar de sintaxis, cambiamos al backend de `plotlyjs()`**" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": null, 100 | "metadata": { 101 | "collapsed": true 102 | }, 103 | "outputs": [], 104 | "source": [ 105 | "plotlyjs()" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": null, 111 | "metadata": { 112 | "collapsed": true 113 | }, 114 | "outputs": [], 115 | "source": [ 116 | "plot(x, y, label=\"line\") \n", 117 | "scatter!(x, y, label=\"points\") " 118 | ] 119 | }, 120 | { 121 | "cell_type": "markdown", 122 | "metadata": { 123 | "collapsed": true 124 | }, 125 | "source": [ 126 | "Y nos fijamos como cambia la primera gráfica de la segunda" 127 | ] 128 | }, 129 | { 130 | "cell_type": "markdown", 131 | "metadata": {}, 132 | "source": [ 133 | "## Subiendo de nivel\n", 134 | "\n", 135 | "La sintaxis para agregar títulos y líneas es bastante directa.\n", 136 | "\n", 137 | "Ahora, en el nombre de la ciencia, vamos a examinar la relación entre la temperatura global y el número de piratas entre 1860 y 2000." 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": null, 143 | "metadata": { 144 | "collapsed": true 145 | }, 146 | "outputs": [], 147 | "source": [ 148 | "globaltemperatures = [14.4, 14.5, 14.8, 15.2, 15.5, 15.8]\n", 149 | "numpirates = [45000, 20000, 15000, 5000, 400, 17]" 150 | ] 151 | }, 152 | { 153 | "cell_type": "code", 154 | "execution_count": null, 155 | "metadata": { 156 | "collapsed": true 157 | }, 158 | "outputs": [], 159 | "source": [ 160 | "# Primero plotteamos los datos\n", 161 | "plot(numpirates, globaltemperatures, legend=false)\n", 162 | "scatter!(numpirates, globaltemperatures, legend=false)\n", 163 | "\n", 164 | "# Agregamos Títulos y etiquetas/labels.\n", 165 | "xlabel!(\"Número de piratas [Apróx.]\")\n", 166 | "ylabel!(\"Temperatura Global (C)\")\n", 167 | "title!(\"Influencia de población de piratas en calentamiento global\")" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": null, 173 | "metadata": { 174 | "collapsed": true 175 | }, 176 | "outputs": [], 177 | "source": [ 178 | "# Primero graficamos datos\n", 179 | "plot(numpirates, globaltemperatures, legend=false)\n", 180 | "scatter!(numpirates, globaltemperatures, legend=false)\n", 181 | "\n", 182 | "# Este comando invierte el eje x para que podamos ver los cambios hacia adelante en el tiempo, de 1860 a 2000\n", 183 | "xflip!()\n", 184 | "\n", 185 | "# Add titles and labels\n", 186 | "xlabel!(\"Number of Pirates [Approximate]\")\n", 187 | "ylabel!(\"Global Temperature (C)\")\n", 188 | "title!(\"Influence of pirate population on global warming\")" 189 | ] 190 | }, 191 | { 192 | "cell_type": "markdown", 193 | "metadata": {}, 194 | "source": [ 195 | "Para crear una gráfica con subráficas, sólo nombramos a cada una de las subgráficas y las ponemos junto con la especificación de diseño en una sóla llamada a `plot`." 196 | ] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": null, 201 | "metadata": { 202 | "collapsed": true 203 | }, 204 | "outputs": [], 205 | "source": [ 206 | "p1 = plot(x, x)\n", 207 | "p2 = plot(x, x.^2)\n", 208 | "p3 = plot(x, x.^3)\n", 209 | "p4 = plot(x, x.^4)\n", 210 | "plot(p1,p2,p3,p4,layout=(2,2),legend=false)" 211 | ] 212 | }, 213 | { 214 | "cell_type": "markdown", 215 | "metadata": { 216 | "collapsed": true 217 | }, 218 | "source": [ 219 | "### Ejercicios\n", 220 | "\n", 221 | "8.1 Grafica y vs x para `y = x^2` usando el backend de PyPlot." 222 | ] 223 | }, 224 | { 225 | "cell_type": "code", 226 | "execution_count": null, 227 | "metadata": { 228 | "collapsed": true 229 | }, 230 | "outputs": [], 231 | "source": [] 232 | } 233 | ], 234 | "metadata": { 235 | "anaconda-cloud": {}, 236 | "kernelspec": { 237 | "display_name": "Julia 0.6.0", 238 | "language": "julia", 239 | "name": "julia-0.6" 240 | }, 241 | "language_info": { 242 | "file_extension": ".jl", 243 | "mimetype": "application/julia", 244 | "name": "julia", 245 | "version": "0.6.0" 246 | }, 247 | "toc": { 248 | "nav_menu": { 249 | "height": "66px", 250 | "width": "252px" 251 | }, 252 | "navigate_menu": true, 253 | "number_sections": true, 254 | "sideBar": true, 255 | "threshold": "2", 256 | "toc_cell": false, 257 | "toc_section_display": "block", 258 | "toc_window_display": false 259 | } 260 | }, 261 | "nbformat": 4, 262 | "nbformat_minor": 2 263 | } 264 | -------------------------------------------------------------------------------- /es/ 9. Despacho multiple.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Despacho múltiple / multiple dispatch" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "En este notebook vamos a explorar **multiple dispatch**, un concepto fundamental en Julia.\n", 15 | "\n", 16 | "Multiple dispatch permite software:\n", 17 | "- rápido\n", 18 | "- extendible\n", 19 | "- programable\n", 20 | "- divertido para experimentar" 21 | ] 22 | }, 23 | { 24 | "cell_type": "markdown", 25 | "metadata": {}, 26 | "source": [ 27 | "Para entender el despacho múltiple en Julia, observemos el operador `+`.
\n", 28 | "\n", 29 | "Si llamamos `methods()` sobre `+`, podemos ver todas las definiciones de `+`" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": null, 35 | "metadata": { 36 | "collapsed": true 37 | }, 38 | "outputs": [], 39 | "source": [ 40 | "methods(+)" 41 | ] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "metadata": {}, 46 | "source": [ 47 | "Podemos usar el macro de `@which` para saber qué método en particular estamos usando de `+`.
\n", 48 | "\n", 49 | "Distintos métodos se usan en cada uno de estos ejemplos." 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": null, 55 | "metadata": { 56 | "collapsed": true 57 | }, 58 | "outputs": [], 59 | "source": [ 60 | "@which 3 + 3" 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": null, 66 | "metadata": { 67 | "collapsed": true 68 | }, 69 | "outputs": [], 70 | "source": [ 71 | "@which 3.0 + 3.0 " 72 | ] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": null, 77 | "metadata": { 78 | "collapsed": true 79 | }, 80 | "outputs": [], 81 | "source": [ 82 | "@which 3 + 3.0" 83 | ] 84 | }, 85 | { 86 | "cell_type": "markdown", 87 | "metadata": {}, 88 | "source": [ 89 | "Aún más, pues podemos definir nuevos métodos de `+`.
\n", 90 | "\n", 91 | "Primero tenemos que importar `+` de Base." 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": null, 97 | "metadata": { 98 | "collapsed": true 99 | }, 100 | "outputs": [], 101 | "source": [ 102 | "import Base: +" 103 | ] 104 | }, 105 | { 106 | "cell_type": "markdown", 107 | "metadata": {}, 108 | "source": [ 109 | "Digamos que queremos concatenar elementos con `+`. Sin extender el método, no funciona" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": null, 115 | "metadata": { 116 | "collapsed": true 117 | }, 118 | "outputs": [], 119 | "source": [ 120 | "\"hello \" + \"world!\"" 121 | ] 122 | }, 123 | { 124 | "cell_type": "code", 125 | "execution_count": null, 126 | "metadata": { 127 | "collapsed": true 128 | }, 129 | "outputs": [], 130 | "source": [ 131 | "@which \"hello \" + \"world!\"" 132 | ] 133 | }, 134 | { 135 | "cell_type": "markdown", 136 | "metadata": {}, 137 | "source": [ 138 | "Entonces agregamos a `+` un método que toma dos cadenas y las concatena" 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": null, 144 | "metadata": { 145 | "collapsed": true 146 | }, 147 | "outputs": [], 148 | "source": [ 149 | "+(x::String, y::String) = string(x, y)" 150 | ] 151 | }, 152 | { 153 | "cell_type": "code", 154 | "execution_count": null, 155 | "metadata": { 156 | "collapsed": true 157 | }, 158 | "outputs": [], 159 | "source": [ 160 | "\"hello \" + \"world!\"" 161 | ] 162 | }, 163 | { 164 | "cell_type": "markdown", 165 | "metadata": {}, 166 | "source": [ 167 | "¡Funciona! Y si queremos más, podemos comprobarnos que Julia ha despachado sobre los tipos de \"hello\" y \"world!\", sobre el método que acabamos de definir" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": null, 173 | "metadata": { 174 | "collapsed": true 175 | }, 176 | "outputs": [], 177 | "source": [ 178 | "@which \"hello \" + \"world!\"" 179 | ] 180 | }, 181 | { 182 | "cell_type": "markdown", 183 | "metadata": { 184 | "collapsed": true 185 | }, 186 | "source": [ 187 | "Vamos por un ejemplo más" 188 | ] 189 | }, 190 | { 191 | "cell_type": "code", 192 | "execution_count": null, 193 | "metadata": { 194 | "collapsed": true 195 | }, 196 | "outputs": [], 197 | "source": [ 198 | "foo(x, y) = println(\"duck-typed foo!\")\n", 199 | "foo(x::Int, y::Float64) = println(\"foo con entero y flotante!\")\n", 200 | "foo(x::Float64, y::Float64) = println(\"foo con dos flotantes!\")\n", 201 | "foo(x::Int, y::Int) = println(\"foo con dos enteros!\")" 202 | ] 203 | }, 204 | { 205 | "cell_type": "code", 206 | "execution_count": null, 207 | "metadata": { 208 | "collapsed": true 209 | }, 210 | "outputs": [], 211 | "source": [ 212 | "foo(1, 1)" 213 | ] 214 | }, 215 | { 216 | "cell_type": "code", 217 | "execution_count": null, 218 | "metadata": { 219 | "collapsed": true 220 | }, 221 | "outputs": [], 222 | "source": [ 223 | "foo(1., 1.)" 224 | ] 225 | }, 226 | { 227 | "cell_type": "code", 228 | "execution_count": null, 229 | "metadata": { 230 | "collapsed": true 231 | }, 232 | "outputs": [], 233 | "source": [ 234 | "foo(1, 1.0)" 235 | ] 236 | }, 237 | { 238 | "cell_type": "code", 239 | "execution_count": null, 240 | "metadata": { 241 | "collapsed": true 242 | }, 243 | "outputs": [], 244 | "source": [ 245 | "foo(true, false)" 246 | ] 247 | }, 248 | { 249 | "cell_type": "markdown", 250 | "metadata": {}, 251 | "source": [ 252 | "Nota que el último ejemplo aplica por default el caso de 'duck-typed foo' porque no había un método definido exclusivamente para dos booleanos." 253 | ] 254 | }, 255 | { 256 | "cell_type": "markdown", 257 | "metadata": { 258 | "collapsed": true 259 | }, 260 | "source": [ 261 | "### Ejercicios\n", 262 | "\n", 263 | "#### 9.1\n", 264 | "\n", 265 | "Agrega un método para `+` que aplique un cifrado de César a una cadena (cómo en el notebook 6) tal que\n", 266 | "\n", 267 | "```julia\n", 268 | "\"hello\" + 4 == \"lipps\"\n", 269 | "```" 270 | ] 271 | }, 272 | { 273 | "cell_type": "code", 274 | "execution_count": null, 275 | "metadata": { 276 | "collapsed": true 277 | }, 278 | "outputs": [], 279 | "source": [] 280 | }, 281 | { 282 | "cell_type": "markdown", 283 | "metadata": {}, 284 | "source": [ 285 | "#### 9.2\n", 286 | "\n", 287 | "Checa que has extendido propiamente `+` recorriendo la próxima cadena para atrás por 3 letras:\n", 288 | "\n", 289 | "\"Gr#qrw#phggoh#lq#wkh#diidluv#ri#gudjrqv#iru#|rx#duh#fuxqfk|#dqg#wdvwh#jrrg#zlwk#nhwfkxs1\"" 290 | ] 291 | }, 292 | { 293 | "cell_type": "code", 294 | "execution_count": null, 295 | "metadata": { 296 | "collapsed": true 297 | }, 298 | "outputs": [], 299 | "source": [] 300 | } 301 | ], 302 | "metadata": { 303 | "anaconda-cloud": {}, 304 | "kernelspec": { 305 | "display_name": "Julia 0.6.0", 306 | "language": "julia", 307 | "name": "julia-0.6" 308 | }, 309 | "language": "Julia", 310 | "language_info": { 311 | "file_extension": ".jl", 312 | "mimetype": "application/julia", 313 | "name": "julia", 314 | "version": "0.6.0" 315 | }, 316 | "toc": { 317 | "nav_menu": { 318 | "height": "119px", 319 | "width": "251px" 320 | }, 321 | "navigate_menu": true, 322 | "number_sections": true, 323 | "sideBar": true, 324 | "threshold": "2", 325 | "toc_cell": false, 326 | "toc_section_display": "block", 327 | "toc_window_display": false 328 | } 329 | }, 330 | "nbformat": 4, 331 | "nbformat_minor": 1 332 | } 333 | -------------------------------------------------------------------------------- /es/10. Algebra lineal basica.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Álgebra lineal básica en Julia\n", 8 | "Autor: Andreas Noack Jensen (MIT) (http://www.econ.ku.dk/phdstudent/noack/)\n", 9 | "(con edición de Jane Herriman)" 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "Julia's syntax is very similar to other languages but there are some important differences. Define a matrix of random normal variates" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": { 23 | "collapsed": true 24 | }, 25 | "outputs": [], 26 | "source": [ 27 | "A = rand(1:4,3,3)" 28 | ] 29 | }, 30 | { 31 | "cell_type": "markdown", 32 | "metadata": {}, 33 | "source": [ 34 | "Definir un vector de unos" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": null, 40 | "metadata": { 41 | "collapsed": true 42 | }, 43 | "outputs": [], 44 | "source": [ 45 | "x = fill(1.0, (3))" 46 | ] 47 | }, 48 | { 49 | "cell_type": "markdown", 50 | "metadata": {}, 51 | "source": [ 52 | "Notamos que $A$ tiene el tipo Array{Int64,2} pero $x$ tiene tipo Array{Int64,1}. Julia define los alias a Vector{Type}=Array{Type,1} y Matrix{Type}=Array{Type,2}.\n", 53 | "\n", 54 | "Muchas de las operaciones básicas son idénticas a otros lenguajes\n", 55 | "\n", 56 | "#### Multiplicación" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": null, 62 | "metadata": { 63 | "collapsed": true 64 | }, 65 | "outputs": [], 66 | "source": [ 67 | "b = A*x" 68 | ] 69 | }, 70 | { 71 | "cell_type": "markdown", 72 | "metadata": {}, 73 | "source": [ 74 | "#### Traspuestas\n", 75 | "Como en otros lenguajes, `A'` es la transpuesta conjugada mientras que `A.'` es sólo la traspuesta" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": null, 81 | "metadata": { 82 | "collapsed": true 83 | }, 84 | "outputs": [], 85 | "source": [ 86 | "Asym = A + A'" 87 | ] 88 | }, 89 | { 90 | "cell_type": "markdown", 91 | "metadata": {}, 92 | "source": [ 93 | "#### Multiplicación traspuesta\n", 94 | "Julia nos permite escribir esto sin *" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": null, 100 | "metadata": { 101 | "collapsed": true 102 | }, 103 | "outputs": [], 104 | "source": [ 105 | "Apd = A'A" 106 | ] 107 | }, 108 | { 109 | "cell_type": "markdown", 110 | "metadata": {}, 111 | "source": [ 112 | "#### Resolviendo sistemas lineales\n", 113 | "El problema $Ax=b$ para $A$ cuadrada se resulve con la función \\." 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": null, 119 | "metadata": { 120 | "collapsed": true 121 | }, 122 | "outputs": [], 123 | "source": [ 124 | "A\\b" 125 | ] 126 | }, 127 | { 128 | "cell_type": "markdown", 129 | "metadata": {}, 130 | "source": [ 131 | "#### Sistemas sobredeterminados\n", 132 | "Cuando nuestra matriz es alta (número de renglones mayores al número de columnas), tenemos un sistema lineal sobredeterminado.\n", 133 | "\n", 134 | "\n", 135 | "En este caso \\ calcula la de mínimos cuadrados" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": null, 141 | "metadata": { 142 | "collapsed": true 143 | }, 144 | "outputs": [], 145 | "source": [ 146 | "Atall = rand(3, 2)\n", 147 | "display(Atall)\n", 148 | "Atall\\b" 149 | ] 150 | }, 151 | { 152 | "cell_type": "markdown", 153 | "metadata": {}, 154 | "source": [ 155 | "La función \\ también sirve ocn problemas deficientes de rango de mínimos cuadrados. En este caso, la solución no es única y Julia regresa el valor con la menor norma.\n", 156 | "\n", 157 | "Para crear un problema de rango deficiente de mínimos cuadrados, vamos a crear una matriz deficiente en rango con columnas linealmente dependientes" 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": null, 163 | "metadata": { 164 | "collapsed": true 165 | }, 166 | "outputs": [], 167 | "source": [ 168 | "v = randn(3)\n", 169 | "rankdef = [v v]" 170 | ] 171 | }, 172 | { 173 | "cell_type": "code", 174 | "execution_count": null, 175 | "metadata": { 176 | "collapsed": true 177 | }, 178 | "outputs": [], 179 | "source": [ 180 | "rankdef\\b" 181 | ] 182 | }, 183 | { 184 | "cell_type": "markdown", 185 | "metadata": {}, 186 | "source": [ 187 | "#### Sistemas indeterminados\n", 188 | "cuando A es corta (número de columnas mayor al número de renglones), tenemos un sistema indeterminado\n", 189 | "\n", 190 | "En este caso \\ regresa la solución con la norma mínima" 191 | ] 192 | }, 193 | { 194 | "cell_type": "code", 195 | "execution_count": null, 196 | "metadata": { 197 | "collapsed": true 198 | }, 199 | "outputs": [], 200 | "source": [ 201 | "Ashort = rand(2, 3)\n", 202 | "display(Ashort)\n", 203 | "Ashort\\b[1:2]" 204 | ] 205 | }, 206 | { 207 | "cell_type": "markdown", 208 | "metadata": {}, 209 | "source": [ 210 | "### Ejercicios\n", 211 | "\n", 212 | "\n", 213 | "\n", 214 | "```\n", 215 | "A = [\n", 216 | " 1 2 3 4 5 6 7 8 9 10\n", 217 | " 1 2 3 4 5 6 7 8 9 10\n", 218 | " 1 2 3 4 5 6 7 8 9 10\n", 219 | " 1 2 3 4 5 6 7 8 9 10\n", 220 | " 1 2 3 4 5 6 7 8 9 10\n", 221 | " 1 2 3 4 5 6 7 8 9 10\n", 222 | " 1 2 3 4 5 6 7 8 9 10\n", 223 | " 1 2 3 4 5 6 7 8 9 10\n", 224 | " 1 2 3 4 5 6 7 8 9 10\n", 225 | " 1 2 3 4 5 6 7 8 9 10\n", 226 | " ]\n", 227 | "```\n", 228 | "\n", 229 | "Quieres obtener\n", 230 | "\n", 231 | "```\n", 232 | "A = [\n", 233 | " 7 8 9 10 1 2 3 4 5 6\n", 234 | " 7 8 9 10 1 2 3 4 5 6\n", 235 | " 7 8 9 10 1 2 3 4 5 6\n", 236 | " 7 8 9 10 1 2 3 4 5 6\n", 237 | " 7 8 9 10 1 2 3 4 5 6\n", 238 | " 7 8 9 10 1 2 3 4 5 6\n", 239 | " 7 8 9 10 1 2 3 4 5 6\n", 240 | " 7 8 9 10 1 2 3 4 5 6\n", 241 | " 7 8 9 10 1 2 3 4 5 6\n", 242 | " 7 8 9 10 1 2 3 4 5 6\n", 243 | " ]\n", 244 | "```" 245 | ] 246 | }, 247 | { 248 | "cell_type": "code", 249 | "execution_count": null, 250 | "metadata": { 251 | "collapsed": true 252 | }, 253 | "outputs": [], 254 | "source": [] 255 | }, 256 | { 257 | "cell_type": "markdown", 258 | "metadata": {}, 259 | "source": [ 260 | "10.2 Toma el producto de un vector `v` con sí mismo." 261 | ] 262 | }, 263 | { 264 | "cell_type": "code", 265 | "execution_count": null, 266 | "metadata": { 267 | "collapsed": true 268 | }, 269 | "outputs": [], 270 | "source": [] 271 | }, 272 | { 273 | "cell_type": "markdown", 274 | "metadata": {}, 275 | "source": [ 276 | "10.3 Toma el producto de un vector `v` con sí mismo." 277 | ] 278 | }, 279 | { 280 | "cell_type": "code", 281 | "execution_count": null, 282 | "metadata": { 283 | "collapsed": true 284 | }, 285 | "outputs": [], 286 | "source": [] 287 | } 288 | ], 289 | "metadata": { 290 | "kernelspec": { 291 | "display_name": "Julia 0.6.0", 292 | "language": "julia", 293 | "name": "julia-0.6" 294 | }, 295 | "language": "Julia", 296 | "language_info": { 297 | "file_extension": ".jl", 298 | "mimetype": "application/julia", 299 | "name": "julia", 300 | "version": "0.6.0" 301 | } 302 | }, 303 | "nbformat": 4, 304 | "nbformat_minor": 1 305 | } 306 | -------------------------------------------------------------------------------- /pt/00.Notebooks_jupyter.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Introdução aos notebooks Jupyter\n", 8 | "\n", 9 | "### Executando uma célula\n", 10 | "Para executar código numa célula, selecione a célula e (1) pressione `Shift` e `Enter` ou (2) pressione o botão executar (botão com flecha apontando para a direita) acima.\n" 11 | ] 12 | }, 13 | { 14 | "cell_type": "code", 15 | "execution_count": null, 16 | "metadata": {}, 17 | "outputs": [], 18 | "source": [ 19 | "1 + 1\n", 20 | "2 + 2" 21 | ] 22 | }, 23 | { 24 | "cell_type": "markdown", 25 | "metadata": {}, 26 | "source": [ 27 | "Se esta é a sua primeira vez utilizando notebooks do Jupyter, repare que, por _default_ apenas a última linha é impressa quando você executa a célula. Você pode suprimir isso adicionando um ponto e vírgula" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": null, 33 | "metadata": {}, 34 | "outputs": [], 35 | "source": [ 36 | "1 + 1\n", 37 | "2 + 2;" 38 | ] 39 | }, 40 | { 41 | "cell_type": "markdown", 42 | "metadata": {}, 43 | "source": [ 44 | "### Como conseguir documentação para funções do Julia\n", 45 | "\n", 46 | "Para acessar a documentação de uma função com a qual você não está familiarizado, ponha uma interrogação na sua frente e execute a célula (também funciona no REPL!). REPL é *Read-Eval-Print-Loop* e designa o terminal Julia." 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": null, 52 | "metadata": {}, 53 | "outputs": [], 54 | "source": [ 55 | "?println" 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "### Como usar comandos do shell (prompt)\n", 63 | "\n", 64 | "Digite `;` e os comandos shell que você quer. Por exemplo, " 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": null, 70 | "metadata": {}, 71 | "outputs": [], 72 | "source": [ 73 | ";ls" 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": null, 79 | "metadata": {}, 80 | "outputs": [], 81 | "source": [ 82 | ";pwd" 83 | ] 84 | }, 85 | { 86 | "cell_type": "markdown", 87 | "metadata": { 88 | "collapsed": true, 89 | "slideshow": { 90 | "slide_type": "slide" 91 | } 92 | }, 93 | "source": [ 94 | "Isto também function no REPL!" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": null, 100 | "metadata": {}, 101 | "outputs": [], 102 | "source": [] 103 | } 104 | ], 105 | "metadata": { 106 | "kernelspec": { 107 | "display_name": "Julia 1.1.0", 108 | "language": "julia", 109 | "name": "julia-1.1" 110 | }, 111 | "language_info": { 112 | "file_extension": ".jl", 113 | "mimetype": "application/julia", 114 | "name": "julia", 115 | "version": "1.0.1" 116 | } 117 | }, 118 | "nbformat": 4, 119 | "nbformat_minor": 2 120 | } 121 | -------------------------------------------------------------------------------- /pt/01.Comecando_com_Julia.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Começando com Julia\n", 8 | "\n", 9 | "Tópicos:\n", 10 | "1. Como imprimir algo\n", 11 | "2. Como criar variáveis\n", 12 | "3. Como fazer um comentário\n", 13 | "4. Sintaxe básica para matemática" 14 | ] 15 | }, 16 | { 17 | "cell_type": "markdown", 18 | "metadata": {}, 19 | "source": [ 20 | "## Como imprimir\n", 21 | "\n", 22 | "Em Julia, geralmente se usa a função `println()` para imprimir algo" 23 | ] 24 | }, 25 | { 26 | "cell_type": "code", 27 | "execution_count": null, 28 | "metadata": {}, 29 | "outputs": [], 30 | "source": [ 31 | "println(\"I'm excited to learn Julia!\")" 32 | ] 33 | }, 34 | { 35 | "cell_type": "markdown", 36 | "metadata": {}, 37 | "source": [ 38 | "## Como criar variáveis\n", 39 | "\n", 40 | "Tudo o que precisamos é o nome da variável, um valor e sinal de igualdade!
\n", 41 | "Julia acha os tipos das variáveis para a gente." 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": null, 47 | "metadata": {}, 48 | "outputs": [], 49 | "source": [ 50 | "my_answer = 42\n", 51 | "typeof(my_answer)" 52 | ] 53 | }, 54 | { 55 | "cell_type": "code", 56 | "execution_count": null, 57 | "metadata": {}, 58 | "outputs": [], 59 | "source": [ 60 | "my_pi = 3.14159\n", 61 | "typeof(my_pi)" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": null, 67 | "metadata": {}, 68 | "outputs": [], 69 | "source": [ 70 | "😺 = \"smiley cat!\"\n", 71 | "typeof(😺)" 72 | ] 73 | }, 74 | { 75 | "cell_type": "markdown", 76 | "metadata": {}, 77 | "source": [ 78 | "Para digitar um smiley cat, use o recurso de completação de tabulação para selecionar o nome do emoji e use tab novamente" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": null, 84 | "metadata": {}, 85 | "outputs": [], 86 | "source": [ 87 | "# \\:smi + --> select with down arrow + ---> + to complete" 88 | ] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "metadata": {}, 93 | "source": [ 94 | "Após dar um valor a uma variável, podemos dar um outro valor de outro tipo sem qualquer problema." 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": null, 100 | "metadata": {}, 101 | "outputs": [], 102 | "source": [ 103 | "😺 = 1" 104 | ] 105 | }, 106 | { 107 | "cell_type": "code", 108 | "execution_count": null, 109 | "metadata": {}, 110 | "outputs": [], 111 | "source": [ 112 | "typeof(😺)" 113 | ] 114 | }, 115 | { 116 | "cell_type": "markdown", 117 | "metadata": {}, 118 | "source": [ 119 | "Repare: Julia permite que escrevamos código super genérico e 😺 é um exemplo disso.\n", 120 | "\n", 121 | "Isso permite que escrevamos código como esse:" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": null, 127 | "metadata": {}, 128 | "outputs": [], 129 | "source": [ 130 | "😀 = 0\n", 131 | "😞 = -1" 132 | ] 133 | }, 134 | { 135 | "cell_type": "code", 136 | "execution_count": null, 137 | "metadata": {}, 138 | "outputs": [], 139 | "source": [ 140 | "😺 + 😞 == 😀" 141 | ] 142 | }, 143 | { 144 | "cell_type": "markdown", 145 | "metadata": {}, 146 | "source": [ 147 | "## Como comentar" 148 | ] 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": null, 153 | "metadata": {}, 154 | "outputs": [], 155 | "source": [ 156 | "# Você pode fazer comentários de uma única linha usando a tecla do jogo da velha" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": null, 162 | "metadata": {}, 163 | "outputs": [], 164 | "source": [ 165 | "#=\n", 166 | "\n", 167 | "Para comentários com mais de uma linha, use a sequência '#= =#'.\n", 168 | "\n", 169 | "=#" 170 | ] 171 | }, 172 | { 173 | "cell_type": "markdown", 174 | "metadata": {}, 175 | "source": [ 176 | "## Sintaxe para matemática básica" 177 | ] 178 | }, 179 | { 180 | "cell_type": "code", 181 | "execution_count": null, 182 | "metadata": {}, 183 | "outputs": [], 184 | "source": [ 185 | "sum = 3 + 7" 186 | ] 187 | }, 188 | { 189 | "cell_type": "code", 190 | "execution_count": null, 191 | "metadata": {}, 192 | "outputs": [], 193 | "source": [ 194 | "difference = 10 - 3" 195 | ] 196 | }, 197 | { 198 | "cell_type": "code", 199 | "execution_count": null, 200 | "metadata": {}, 201 | "outputs": [], 202 | "source": [ 203 | "product = 20 * 5" 204 | ] 205 | }, 206 | { 207 | "cell_type": "code", 208 | "execution_count": null, 209 | "metadata": {}, 210 | "outputs": [], 211 | "source": [ 212 | "quotient = 100 / 10" 213 | ] 214 | }, 215 | { 216 | "cell_type": "code", 217 | "execution_count": null, 218 | "metadata": {}, 219 | "outputs": [], 220 | "source": [ 221 | "power = 10 ^ 2" 222 | ] 223 | }, 224 | { 225 | "cell_type": "code", 226 | "execution_count": null, 227 | "metadata": {}, 228 | "outputs": [], 229 | "source": [ 230 | "modulus = 101 % 2" 231 | ] 232 | }, 233 | { 234 | "cell_type": "markdown", 235 | "metadata": {}, 236 | "source": [ 237 | "### Exercícios\n", 238 | "\n", 239 | "#### 1.1 \n", 240 | "Procure a documentação para a função `convert`." 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": null, 246 | "metadata": {}, 247 | "outputs": [], 248 | "source": [] 249 | }, 250 | { 251 | "cell_type": "markdown", 252 | "metadata": {}, 253 | "source": [ 254 | "#### 1.2 \n", 255 | "Dê o valor `365` a uma variável chamada `days`. Converta `days` para float (ponto flutuante)." 256 | ] 257 | }, 258 | { 259 | "cell_type": "code", 260 | "execution_count": null, 261 | "metadata": {}, 262 | "outputs": [], 263 | "source": [] 264 | }, 265 | { 266 | "cell_type": "markdown", 267 | "metadata": {}, 268 | "source": [ 269 | "#### 1.3 \n", 270 | "Veja o que acontece quando você executa\n", 271 | "\n", 272 | "```julia\n", 273 | "convert(Int64, \"1\")\n", 274 | "```\n", 275 | "e\n", 276 | "\n", 277 | "```julia\n", 278 | "parse(Int64, \"1\")\n", 279 | "```" 280 | ] 281 | } 282 | ], 283 | "metadata": { 284 | "kernelspec": { 285 | "display_name": "Julia 1.1.0", 286 | "language": "julia", 287 | "name": "julia-1.1" 288 | }, 289 | "language_info": { 290 | "file_extension": ".jl", 291 | "mimetype": "application/julia", 292 | "name": "julia", 293 | "version": "1.0.0" 294 | } 295 | }, 296 | "nbformat": 4, 297 | "nbformat_minor": 2 298 | } 299 | -------------------------------------------------------------------------------- /pt/02.Strings.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Strings (cadeias de caracteres)\n", 10 | "\n", 11 | "Tópicos:\n", 12 | "1. Como criar uma string\n", 13 | "2. Interpolação de string\n", 14 | "3. Concatenation de string" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "## Como criar uma string\n", 22 | "\n", 23 | "Inclua os caracteres dentreo de \" \" ou \"\"\" \"\"\"!" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": null, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "s1 = \"I am a string.\"" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": null, 38 | "metadata": {}, 39 | "outputs": [], 40 | "source": [ 41 | "s2 = \"\"\"I am also a string. \"\"\"" 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "Existem algumas diferenças entre strings usando aspas simples ou triplas.
\n", 49 | "Uma diferença é que no segundo caso, você pode usar aspas dentro do código." 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": null, 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [ 58 | "\"Here, we get an \"error\" because it's ambiguous where this string ends \"" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": null, 64 | "metadata": {}, 65 | "outputs": [], 66 | "source": [ 67 | "\"\"\"Look, Mom, no \"errors\"!!! \"\"\"" 68 | ] 69 | }, 70 | { 71 | "cell_type": "markdown", 72 | "metadata": {}, 73 | "source": [ 74 | "Perceba que ' ' define um caracter, mas não uma string!" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": null, 80 | "metadata": {}, 81 | "outputs": [], 82 | "source": [ 83 | "typeof('a')" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": null, 89 | "metadata": {}, 90 | "outputs": [], 91 | "source": [ 92 | "'Teremos um erro aqui'" 93 | ] 94 | }, 95 | { 96 | "cell_type": "markdown", 97 | "metadata": {}, 98 | "source": [ 99 | "## Interpolation de string\n", 100 | "\n", 101 | "Pode-se usar o símbolo $ para inserir variáveis já existentes dentro de uma string e avaliar expressões dentro da string.
\n" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": null, 107 | "metadata": {}, 108 | "outputs": [], 109 | "source": [ 110 | "name = \"Jane\"\n", 111 | "num_fingers = 10\n", 112 | "num_toes = 10" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": null, 118 | "metadata": {}, 119 | "outputs": [], 120 | "source": [ 121 | "println(\"Hello, my name is $name.\")\n", 122 | "println(\"I have $num_fingers fingers and $num_toes toes.\")" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": null, 128 | "metadata": {}, 129 | "outputs": [], 130 | "source": [ 131 | " println(\"That is $(num_fingers + num_toes) digits in all!!\")" 132 | ] 133 | }, 134 | { 135 | "cell_type": "markdown", 136 | "metadata": {}, 137 | "source": [ 138 | "## Concatenation string\n", 139 | "\n", 140 | "A seguir são mostrados três maneiras de concatenar strings!

\n", 141 | "A primeira é usar a função `string()`.
\n", 142 | "`string()` converte elementos que não são strings em strings." 143 | ] 144 | }, 145 | { 146 | "cell_type": "code", 147 | "execution_count": null, 148 | "metadata": {}, 149 | "outputs": [], 150 | "source": [ 151 | "s3 = \"How many cats \";\n", 152 | "s4 = \"is too many cats?\";\n", 153 | "😺 = 10" 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": null, 159 | "metadata": {}, 160 | "outputs": [], 161 | "source": [ 162 | "string(s3, s4)" 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": null, 168 | "metadata": {}, 169 | "outputs": [], 170 | "source": [ 171 | "string(\"I don't know, but \", 😺, \" is too few.\")" 172 | ] 173 | }, 174 | { 175 | "cell_type": "markdown", 176 | "metadata": {}, 177 | "source": [ 178 | "Pode-se usar também `*` para concatenação!" 179 | ] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": null, 184 | "metadata": {}, 185 | "outputs": [], 186 | "source": [ 187 | "s3*s4" 188 | ] 189 | }, 190 | { 191 | "cell_type": "markdown", 192 | "metadata": {}, 193 | "source": [ 194 | "### Exercícios\n", 195 | "\n", 196 | "#### 2.1 \n", 197 | "Crie uma string que diz \"oi\" 1000 vezes, primeiro com `repeat` e em seguida com o operador de exponenciaçãom que chama `*` debaixo do capô." 198 | ] 199 | }, 200 | { 201 | "cell_type": "code", 202 | "execution_count": null, 203 | "metadata": {}, 204 | "outputs": [], 205 | "source": [] 206 | }, 207 | { 208 | "cell_type": "markdown", 209 | "metadata": {}, 210 | "source": [ 211 | "#### 2.2 \n", 212 | "Declare duas variáveis\n", 213 | "\n", 214 | "```julia\n", 215 | "a = 3\n", 216 | "b = 4\n", 217 | "```\n", 218 | "e use-as para criar duas strings:\n", 219 | "```julia\n", 220 | "\"3 + 4\"\n", 221 | "\"7\"\n", 222 | "```" 223 | ] 224 | }, 225 | { 226 | "cell_type": "code", 227 | "execution_count": null, 228 | "metadata": {}, 229 | "outputs": [], 230 | "source": [] 231 | } 232 | ], 233 | "metadata": { 234 | "kernelspec": { 235 | "display_name": "Julia 1.1.0", 236 | "language": "julia", 237 | "name": "julia-1.1" 238 | }, 239 | "language_info": { 240 | "file_extension": ".jl", 241 | "mimetype": "application/julia", 242 | "name": "julia", 243 | "version": "1.0.0" 244 | } 245 | }, 246 | "nbformat": 4, 247 | "nbformat_minor": 2 248 | } 249 | -------------------------------------------------------------------------------- /pt/04.Loops.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Loops (laços)\n", 10 | "\n", 11 | "Topics:\n", 12 | "1. Laço `while`\n", 13 | "2. Laço `for`\n", 14 | "
\n", 15 | "\n", 16 | "## Loops while \n", 17 | "\n", 18 | "A sintaxe para um `while` é\n", 19 | "\n", 20 | "```julia\n", 21 | "while *condição*\n", 22 | " *corpo do laço*\n", 23 | "end\n", 24 | "```\n", 25 | "\n", 26 | "Por exemplo, pode-se usar `while` para iterar sobre um _array_." 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": null, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "n = 0\n", 36 | "while n < 10\n", 37 | " n += 1\n", 38 | " println(n)\n", 39 | "end\n", 40 | "n" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": null, 46 | "metadata": {}, 47 | "outputs": [], 48 | "source": [ 49 | "myfriends = [\"Ted\", \"Robyn\", \"Barney\", \"Lily\", \"Marshall\"]\n", 50 | "\n", 51 | "i = 1\n", 52 | "while i <= length(myfriends)\n", 53 | " friend = myfriends[i]\n", 54 | " println(\"Hi $friend, it's great to see you!\")\n", 55 | " i += 1\n", 56 | "end" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "## Loops for \n", 64 | "\n", 65 | "A sintaxe para um loop `for` é\n", 66 | "\n", 67 | "```julia\n", 68 | "for *var* in *iterável*\n", 69 | " *corpo do laço*\n", 70 | "end\n", 71 | "```\n", 72 | "\n", 73 | "Pode-se usar um loop for para gerar os mesmos resultados anteriores:" 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": null, 79 | "metadata": {}, 80 | "outputs": [], 81 | "source": [ 82 | "for n in 1:10\n", 83 | " println(n)\n", 84 | "end" 85 | ] 86 | }, 87 | { 88 | "cell_type": "code", 89 | "execution_count": null, 90 | "metadata": {}, 91 | "outputs": [], 92 | "source": [ 93 | "myfriends = [\"Ted\", \"Robyn\", \"Barney\", \"Lily\", \"Marshall\"]\n", 94 | "\n", 95 | "for friend in myfriends\n", 96 | " println(\"Hi $friend, it's great to see you!\")\n", 97 | "end" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "Vamos usar loop `for` para criar tabelas de adição, onde o valor de cada entrada é a soma dos índices da linha e coluna.
\n", 105 | "\n", 106 | "Inicialmente vamos inicializar o _array_ com zeros." 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": null, 112 | "metadata": {}, 113 | "outputs": [], 114 | "source": [ 115 | "m, n = 5, 5\n", 116 | "A = fill(0, (m, n))" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": null, 122 | "metadata": {}, 123 | "outputs": [], 124 | "source": [ 125 | "for i in 1:m\n", 126 | " for j in 1:n\n", 127 | " A[i, j] = i + j\n", 128 | " end\n", 129 | "end\n", 130 | "A" 131 | ] 132 | }, 133 | { 134 | "cell_type": "markdown", 135 | "metadata": {}, 136 | "source": [ 137 | "Aqui está algum açúcar sintático para loops `for` aninhados" 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": null, 143 | "metadata": {}, 144 | "outputs": [], 145 | "source": [ 146 | "B = fill(0, (m, n))" 147 | ] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": null, 152 | "metadata": {}, 153 | "outputs": [], 154 | "source": [ 155 | "for i in 1:m, j in 1:n\n", 156 | " B[i, j] = i + j\n", 157 | "end\n", 158 | "B" 159 | ] 160 | }, 161 | { 162 | "cell_type": "markdown", 163 | "metadata": {}, 164 | "source": [ 165 | "O jeito mais \"Julia\"no de fazer isso é usar uma *array comprehension*." 166 | ] 167 | }, 168 | { 169 | "cell_type": "code", 170 | "execution_count": null, 171 | "metadata": {}, 172 | "outputs": [], 173 | "source": [ 174 | "C = [i + j for i in 1:m, j in 1:n]" 175 | ] 176 | }, 177 | { 178 | "cell_type": "markdown", 179 | "metadata": {}, 180 | "source": [ 181 | "### Exercícios\n", 182 | "\n", 183 | "#### 4.1 \n", 184 | "Faça um loop entre os inteiros 1 e 100 e imprima seus quadrados." 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": null, 190 | "metadata": {}, 191 | "outputs": [], 192 | "source": [] 193 | }, 194 | { 195 | "cell_type": "markdown", 196 | "metadata": {}, 197 | "source": [ 198 | "#### 4.2 \n", 199 | "Adicione ao código acima um dicionário que armazena inteiros e seus quadrados, de modo que \n", 200 | "\n", 201 | "```julia\n", 202 | "squares[10] == 100\n", 203 | "```" 204 | ] 205 | }, 206 | { 207 | "cell_type": "code", 208 | "execution_count": null, 209 | "metadata": {}, 210 | "outputs": [], 211 | "source": [] 212 | }, 213 | { 214 | "cell_type": "markdown", 215 | "metadata": { 216 | "collapsed": true 217 | }, 218 | "source": [ 219 | "#### 4.3 \n", 220 | "Use uma _array comprehension_ para criar um _array_ que armazena os qudrados de todos os inteiros entre 1 e 100." 221 | ] 222 | }, 223 | { 224 | "cell_type": "code", 225 | "execution_count": null, 226 | "metadata": {}, 227 | "outputs": [], 228 | "source": [] 229 | } 230 | ], 231 | "metadata": { 232 | "kernelspec": { 233 | "display_name": "Julia 1.1.0", 234 | "language": "julia", 235 | "name": "julia-1.1" 236 | }, 237 | "language_info": { 238 | "file_extension": ".jl", 239 | "mimetype": "application/julia", 240 | "name": "julia", 241 | "version": "1.0.0" 242 | } 243 | }, 244 | "nbformat": 4, 245 | "nbformat_minor": 2 246 | } 247 | -------------------------------------------------------------------------------- /pt/05.Condicionais.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Condicionais\n", 10 | "\n", 11 | "#### Usando a palavra chave `if`\n", 12 | "Em Julia, a sintaxe\n", 13 | "\n", 14 | "```julia\n", 15 | "if *condição 1*\n", 16 | " *opção 1*\n", 17 | "elseif *condição 2*\n", 18 | " *opção 2*\n", 19 | "else\n", 20 | " *opção 3*\n", 21 | "end\n", 22 | "```\n", 23 | "\n", 24 | "isso nos permite a avaliar de maneira condicional uma das nossas opções.\n", 25 | "

\n", 26 | "Por exemplo, podemos querer implementar o teste FizzBuzz: dados um número, N, imprimir \"Fizz\" se N é divisível por 3, \"Byzz\" se for divisível por 5 e \"FizzBuzz\" se for divisível por 3 e 5. Caso contrário, imprimir o próprio número! Defina a sua escolha para `N` aqui:" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": null, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "N = " 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": null, 41 | "metadata": {}, 42 | "outputs": [], 43 | "source": [ 44 | "if (N % 3 == 0) && (N % 5 == 0) # `&&` signifgica \"E\"; % calcula os resto após a divisão\n", 45 | " println(\"FizzBuzz\")\n", 46 | "elseif N % 3 == 0\n", 47 | " println(\"Fizz\")\n", 48 | "elseif N % 5 == 0\n", 49 | " println(\"Buzz\")\n", 50 | "else\n", 51 | " println(N)\n", 52 | "end" 53 | ] 54 | }, 55 | { 56 | "cell_type": "markdown", 57 | "metadata": {}, 58 | "source": [ 59 | "#### usando operador ternário\n", 60 | "\n", 61 | "Pode-se usar o operador ternário com a sintaxe\n", 62 | "\n", 63 | "```julia\n", 64 | "a ? b : c\n", 65 | "```\n", 66 | "\n", 67 | "que é equivalente a\n", 68 | "\n", 69 | "```julia\n", 70 | "if a\n", 71 | " b\n", 72 | "else\n", 73 | " c\n", 74 | "end\n", 75 | "```" 76 | ] 77 | }, 78 | { 79 | "cell_type": "markdown", 80 | "metadata": {}, 81 | "source": [ 82 | "Suponhamos que desejamos saber qual o maior de dois números. Dados os valores `x` e `y` a seguir:" 83 | ] 84 | }, 85 | { 86 | "cell_type": "code", 87 | "execution_count": null, 88 | "metadata": {}, 89 | "outputs": [], 90 | "source": [ 91 | "x =\n", 92 | "y =" 93 | ] 94 | }, 95 | { 96 | "cell_type": "markdown", 97 | "metadata": {}, 98 | "source": [ 99 | "Usando as palavras chave `if` e `else`, pode-se escrever:" 100 | ] 101 | }, 102 | { 103 | "cell_type": "code", 104 | "execution_count": null, 105 | "metadata": {}, 106 | "outputs": [], 107 | "source": [ 108 | "if x > y\n", 109 | " x\n", 110 | "else\n", 111 | " y\n", 112 | "end" 113 | ] 114 | }, 115 | { 116 | "cell_type": "markdown", 117 | "metadata": {}, 118 | "source": [ 119 | "usando o operador ternário, este condicional toma a seguinte forma:" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": null, 125 | "metadata": {}, 126 | "outputs": [], 127 | "source": [ 128 | "(x > y) ? x : y" 129 | ] 130 | }, 131 | { 132 | "cell_type": "markdown", 133 | "metadata": {}, 134 | "source": [ 135 | "#### Usando avaliação curto-circuito (short-circuit evaluation)\n", 136 | "\n", 137 | "Já vimos expressões com a sintaxe \n", 138 | "```julia\n", 139 | "a && b\n", 140 | "```\n", 141 | "\n", 142 | "para returnar `true` (verdadeiro) se ambos `a` e `b` são verdadeiros (`true`). Lógico que se `a` is `false` (falso), Julia não precisa nem saber o valor de `b` para saber que o valor da expressão acima é `false`. Assim, Julia não precisa nem mesmo checar o que `b` é; pode simplesmente usar um \"curto circuito\" e retornar imediatamente o valor `false`. O segundo argumento `b` pode ser uma expressão mais complicada como uma chamada de função com efeito colateral que neste caso não será chamado:" 143 | ] 144 | }, 145 | { 146 | "cell_type": "code", 147 | "execution_count": null, 148 | "metadata": {}, 149 | "outputs": [], 150 | "source": [ 151 | "false && (println(\"hi\"); true)" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": null, 157 | "metadata": {}, 158 | "outputs": [], 159 | "source": [ 160 | "true && (println(\"hi\"); true)" 161 | ] 162 | }, 163 | { 164 | "cell_type": "markdown", 165 | "metadata": {}, 166 | "source": [ 167 | "Por outro lado, se `a` é verdadeiro, Julia sabe que pode simplesmente retornar o valor de `b` como valor da expressão original total. Isso significa que `b` não precisa necessariamente retornar o valor `true` ou `false`. Pode até mesmo ser um erro:" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": null, 173 | "metadata": {}, 174 | "outputs": [], 175 | "source": [ 176 | "(x > 0) && error(\"x não pode ser maior que 0\")" 177 | ] 178 | }, 179 | { 180 | "cell_type": "markdown", 181 | "metadata": {}, 182 | "source": [ 183 | "Algo semelhante ocorre com o operador `||`, que também usa o curto-circuito para executar a operação \"ou\"." 184 | ] 185 | }, 186 | { 187 | "cell_type": "code", 188 | "execution_count": null, 189 | "metadata": {}, 190 | "outputs": [], 191 | "source": [ 192 | "true || println(\"hi\")" 193 | ] 194 | }, 195 | { 196 | "cell_type": "markdown", 197 | "metadata": {}, 198 | "source": [ 199 | "e" 200 | ] 201 | }, 202 | { 203 | "cell_type": "code", 204 | "execution_count": null, 205 | "metadata": {}, 206 | "outputs": [], 207 | "source": [ 208 | "false || println(\"hi\")" 209 | ] 210 | }, 211 | { 212 | "cell_type": "markdown", 213 | "metadata": { 214 | "collapsed": true 215 | }, 216 | "source": [ 217 | "### Exercícios\n", 218 | "\n", 219 | "#### 5.1 \n", 220 | "Escreve um comando condicional que escreve \"par\" se o número é par e \"ímpar\" se o número é ímpar." 221 | ] 222 | }, 223 | { 224 | "cell_type": "code", 225 | "execution_count": null, 226 | "metadata": {}, 227 | "outputs": [], 228 | "source": [] 229 | }, 230 | { 231 | "cell_type": "markdown", 232 | "metadata": {}, 233 | "source": [ 234 | "#### 5.2 \n", 235 | "Repita o exercício anterior utilizando o operador ternário." 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": null, 241 | "metadata": {}, 242 | "outputs": [], 243 | "source": [] 244 | } 245 | ], 246 | "metadata": { 247 | "kernelspec": { 248 | "display_name": "Julia 1.1.0", 249 | "language": "julia", 250 | "name": "julia-1.1" 251 | }, 252 | "language_info": { 253 | "file_extension": ".jl", 254 | "mimetype": "application/julia", 255 | "name": "julia", 256 | "version": "1.0.0" 257 | } 258 | }, 259 | "nbformat": 4, 260 | "nbformat_minor": 2 261 | } 262 | -------------------------------------------------------------------------------- /pt/07.Pacotes.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Pacotes (Packages)\n", 10 | "\n", 11 | "\n", 12 | "Julia tem mais que 2000 pacotes registrados, o que torna os pacotes uma parte essencial do ecossistema da Julia.\n", 13 | "\n", 14 | "Ainda assim, o ecossistema de pacotes ainda precisa amadurecer mais. Importante são pacotes que permitem chamar funções em outras linguagens. Este pacotes fornecem interfaces de funções externas (_foreign function interfaces_) excelentes. Em particular cabe destacar os pacotes `PyCall` e `Rcall` que permitem chamar funções em python e R de maneira simples.\n", 15 | "\n", 16 | "Isto significa que você não precisa esperar que o ecossistema da Julia seja completo para começar a trabalhar com Julia. E isso também significa que você precisa abandonar seu pacote/biblioteca favorito implementado em outra linguagem!\n", 17 | "\n", 18 | "Para ver os pacotes disponíveis, visite\n", 19 | "\n", 20 | "https://pkg.julialang.org/\n", 21 | "ou\n", 22 | "https://juliaobserver.com/\n", 23 | "\n", 24 | "Vamos ver como utilizar um pacote" 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "Na primeira vez que você usa um pacote, você precisa avisar explicitamente ao gerenciador de pacotes que adicione o pacote em questão:" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": null, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [ 40 | "using Pkg\n", 41 | "Pkg.add(\"Example\")" 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "Toda vez que você utiliza Julia (começa uma nova sessão no REPL ou abre um notebook por exemplo), você carrega o pacote com a palavra chave `using`" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": null, 54 | "metadata": {}, 55 | "outputs": [], 56 | "source": [ 57 | "using Example" 58 | ] 59 | }, 60 | { 61 | "cell_type": "markdown", 62 | "metadata": {}, 63 | "source": [ 64 | "No código fonte de `Example.jl` localizado em \n", 65 | "https://github.com/JuliaLang/Example.jl/blob/master/src/Example.jl\n", 66 | "vemos a declaração da seguinte função\n", 67 | "\n", 68 | "```\n", 69 | "hello(who::String) = \"Hello, $who\"\n", 70 | "```\n", 71 | "\n", 72 | "Após carregar `Example`, podemos chamar a função `hello`" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": null, 78 | "metadata": {}, 79 | "outputs": [], 80 | "source": [ 81 | "hello(\"it's me. I was wondering if after all these years you'd like to meet.\")" 82 | ] 83 | }, 84 | { 85 | "cell_type": "markdown", 86 | "metadata": {}, 87 | "source": [ 88 | "Vamos brincar com o pacote `Colors`" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": null, 94 | "metadata": {}, 95 | "outputs": [], 96 | "source": [ 97 | "Pkg.add(\"Colors\")" 98 | ] 99 | }, 100 | { 101 | "cell_type": "code", 102 | "execution_count": null, 103 | "metadata": {}, 104 | "outputs": [], 105 | "source": [ 106 | "using Colors" 107 | ] 108 | }, 109 | { 110 | "cell_type": "markdown", 111 | "metadata": {}, 112 | "source": [ 113 | "Vamos criar uma paleta com 100 cores distintas" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": null, 119 | "metadata": {}, 120 | "outputs": [], 121 | "source": [ 122 | "palette = distinguishable_colors(100)" 123 | ] 124 | }, 125 | { 126 | "cell_type": "markdown", 127 | "metadata": {}, 128 | "source": [ 129 | "Agora podemos criar uma matriz com cores aleatórias usando o comando `rand`" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": null, 135 | "metadata": {}, 136 | "outputs": [], 137 | "source": [ 138 | "rand(palette, 3, 3)" 139 | ] 140 | }, 141 | { 142 | "cell_type": "markdown", 143 | "metadata": {}, 144 | "source": [ 145 | "No próximo notebook, vamos usar um novo pacote para plotar dados." 146 | ] 147 | }, 148 | { 149 | "cell_type": "markdown", 150 | "metadata": {}, 151 | "source": [ 152 | "### Exercícios\n", 153 | "\n", 154 | "#### 7.1 \n", 155 | "Carregue o pacote `Primes`(código fonte em https://github.com/JuliaMath/Primes.jl)." 156 | ] 157 | }, 158 | { 159 | "cell_type": "code", 160 | "execution_count": null, 161 | "metadata": {}, 162 | "outputs": [], 163 | "source": [] 164 | }, 165 | { 166 | "cell_type": "markdown", 167 | "metadata": {}, 168 | "source": [ 169 | "#### 7.2 \n", 170 | "Verifique que você pode usar a função `primes` para encontrar todos os números primos inferiores a 1,000,000." 171 | ] 172 | }, 173 | { 174 | "cell_type": "code", 175 | "execution_count": null, 176 | "metadata": {}, 177 | "outputs": [], 178 | "source": [] 179 | } 180 | ], 181 | "metadata": { 182 | "@webio": { 183 | "lastCommId": null, 184 | "lastKernelId": null 185 | }, 186 | "kernelspec": { 187 | "display_name": "Julia 1.1.0", 188 | "language": "julia", 189 | "name": "julia-1.1" 190 | }, 191 | "language_info": { 192 | "file_extension": ".jl", 193 | "mimetype": "application/julia", 194 | "name": "julia", 195 | "version": "1.0.0" 196 | } 197 | }, 198 | "nbformat": 4, 199 | "nbformat_minor": 2 200 | } 201 | -------------------------------------------------------------------------------- /pt/08.Plotando_graficos.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Plotando gráficos\n", 8 | "\n", 9 | "## O básico\n", 10 | "\n", 11 | "Existem algumas maneiras diferentes de plotar um gráfico em Julia (incluindo chamar `PyPlot`).
\n", 12 | "\n", 13 | "Aqui nós veremos o pacote `Plots.jl`. Se não estiver instalado ainda, você precisa usar o gerenciador de pacote para instalá-lo e Julia vai pré-compilar para você na primeira vez que você usá-lo:" 14 | ] 15 | }, 16 | { 17 | "cell_type": "code", 18 | "execution_count": null, 19 | "metadata": {}, 20 | "outputs": [], 21 | "source": [ 22 | "# using Pkg\n", 23 | "# Pkg.add(\"Plots\")\n", 24 | "using Plots" 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "Uma das vantagens de usar `Plots.jl` é que você pode trocar facilmente os _backends_. Neste notebook, vamos usar os backends `gr()` e `plotlyjs()`.
\n", 32 | "\n", 33 | "Em nome da pesquisa científica, vamos usar este notebook para examinar a relação entre temperatura global e número de piratas entre 1860 e 2000." 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": null, 39 | "metadata": {}, 40 | "outputs": [], 41 | "source": [ 42 | "globaltemperatures = [14.4, 14.5, 14.8, 15.2, 15.5, 15.8]\n", 43 | "numpirates = [45000, 20000, 15000, 5000, 400, 17];" 44 | ] 45 | }, 46 | { 47 | "cell_type": "markdown", 48 | "metadata": {}, 49 | "source": [ 50 | "Plots pode usar diferentes backends — ieto é, bibliotecas que vão de fato desenhar algo — todos usando a mesma API (_Application Programing Interface_). Para começar, vamos usar o backend GR. Você o escolhe chamando a função `gr()`:" 51 | ] 52 | }, 53 | { 54 | "cell_type": "code", 55 | "execution_count": null, 56 | "metadata": {}, 57 | "outputs": [], 58 | "source": [ 59 | "gr()" 60 | ] 61 | }, 62 | { 63 | "cell_type": "markdown", 64 | "metadata": {}, 65 | "source": [ 66 | "e agora, comandos como `plot` e `scatter` podem ser usados para criar gráficos." 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": null, 72 | "metadata": {}, 73 | "outputs": [], 74 | "source": [ 75 | "plot(numpirates, globaltemperatures, label=\"line\") \n", 76 | "scatter!(numpirates, globaltemperatures, label=\"points\") " 77 | ] 78 | }, 79 | { 80 | "cell_type": "markdown", 81 | "metadata": {}, 82 | "source": [ 83 | "O `!` ao final da função `scatter!` quer dizer que a função `scatter!` muda as entradas, indicando que os pontos serão adicionados a uma gráfico já existente.\n", 84 | "\n", 85 | "Em contraste, veja o que ocorre quando você substitui `scatter!` acima pela função que não causa mudanças `scatter`.\n", 86 | "\n", 87 | "A seguir, vamos adicionar algumas informações ao gráfico com os comandos `xlabel!`, `ylabel!`, e `title!`." 88 | ] 89 | }, 90 | { 91 | "cell_type": "code", 92 | "execution_count": null, 93 | "metadata": {}, 94 | "outputs": [], 95 | "source": [ 96 | "xlabel!(\"Number of Pirates [Approximate]\")\n", 97 | "ylabel!(\"Global Temperature (C)\")\n", 98 | "title!(\"Influence of pirate population on global warming\")" 99 | ] 100 | }, 101 | { 102 | "cell_type": "markdown", 103 | "metadata": {}, 104 | "source": [ 105 | "Isso ainda não está legal. O número de piratas diminui desde 1860, então, ler o gráfico da esquerda para a direita é como olhar para o passado ao invés do futuro. Vamos inverter o eixo x para ver o como a população de piratas causou a temperatura global a aumentar com o tempo!" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": null, 111 | "metadata": {}, 112 | "outputs": [], 113 | "source": [ 114 | "xflip!()" 115 | ] 116 | }, 117 | { 118 | "cell_type": "markdown", 119 | "metadata": {}, 120 | "source": [ 121 | "E aqui temos!\n", 122 | "\n", 123 | "Observação: este exercício gerou alguma confusão. :) Isto é uma piada!\n", 124 | "\n", 125 | "**Sem mudar a sintaxe, podemos criar este gráfico usando caracteres Unicode com o backend UnicodePlots**" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": null, 131 | "metadata": {}, 132 | "outputs": [], 133 | "source": [ 134 | "Pkg.add(\"UnicodePlots\")\n", 135 | "unicodeplots()" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": null, 141 | "metadata": {}, 142 | "outputs": [], 143 | "source": [ 144 | "plot(numpirates, globaltemperatures, label=\"line\") \n", 145 | "scatter!(numpirates, globaltemperatures, label=\"points\") \n", 146 | "xlabel!(\"Number of Pirates [Approximate]\")\n", 147 | "ylabel!(\"Global Temperature (C)\")\n", 148 | "title!(\"Influence of pirate population on global warming\")" 149 | ] 150 | }, 151 | { 152 | "cell_type": "markdown", 153 | "metadata": { 154 | "collapsed": true 155 | }, 156 | "source": [ 157 | "Veja como o segundo gráfico difere do original. Usando texto assim parece besteira em um notebook Jupyter onde os recursos gráficos são amplos mas pode ser muito útil em um terminal remoto." 158 | ] 159 | }, 160 | { 161 | "cell_type": "markdown", 162 | "metadata": { 163 | "collapsed": true 164 | }, 165 | "source": [ 166 | "### Exercícios\n", 167 | "\n", 168 | "#### 8.1 \n", 169 | "Dado\n", 170 | "```julia\n", 171 | "x = -10:10\n", 172 | "```\n", 173 | "plote y vs. x para $y = x^2$. Você pode tentart mudar os backends novamente." 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": null, 179 | "metadata": {}, 180 | "outputs": [], 181 | "source": [] 182 | }, 183 | { 184 | "cell_type": "markdown", 185 | "metadata": {}, 186 | "source": [ 187 | "#### 8.2 \n", 188 | "Execute o código a seguir" 189 | ] 190 | }, 191 | { 192 | "cell_type": "code", 193 | "execution_count": null, 194 | "metadata": {}, 195 | "outputs": [], 196 | "source": [ 197 | "p1 = plot(x, x)\n", 198 | "p2 = plot(x, x.^2)\n", 199 | "p3 = plot(x, x.^3)\n", 200 | "p4 = plot(x, x.^4)\n", 201 | "plot(p1, p2, p3, p4, layout = (2, 2), legend = false)" 202 | ] 203 | }, 204 | { 205 | "cell_type": "markdown", 206 | "metadata": {}, 207 | "source": [ 208 | "e então crie um gráfico $4x1$ que usa `p1`, `p2`, `p3`, e `p4` como sub-gráficos." 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": null, 214 | "metadata": {}, 215 | "outputs": [], 216 | "source": [] 217 | } 218 | ], 219 | "metadata": { 220 | "anaconda-cloud": {}, 221 | "kernelspec": { 222 | "display_name": "Julia 1.1.0", 223 | "language": "julia", 224 | "name": "julia-1.1" 225 | }, 226 | "language_info": { 227 | "file_extension": ".jl", 228 | "mimetype": "application/julia", 229 | "name": "julia", 230 | "version": "1.0.0" 231 | }, 232 | "toc": { 233 | "nav_menu": { 234 | "height": "66px", 235 | "width": "252px" 236 | }, 237 | "navigate_menu": true, 238 | "number_sections": true, 239 | "sideBar": true, 240 | "threshold": "2", 241 | "toc_cell": false, 242 | "toc_section_display": "block", 243 | "toc_window_display": false 244 | } 245 | }, 246 | "nbformat": 4, 247 | "nbformat_minor": 2 248 | } 249 | -------------------------------------------------------------------------------- /pt/10.Multi_metodos.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Multi-métodos ou despacho multiplo (multiple dispatch)" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Neste notebook vamos explorar o conceito de **multiple dispatch** - despacho multiplo ou multi métodos, que é uma característica fundamental de programação em Julia.\n", 15 | "\n", 16 | "Multiple dispatch torna o software *genérico* and *rápido*!\n", 17 | "\n", 18 | "#### Começando com algo familar\n", 19 | "\n", 20 | "Para entender multiple dispatch em Julia, comecemos com algo que já vimos.\n", 21 | "\n", 22 | "Podemos criar funções em Julia sem fornecer qualquer tipo de informação sobre os tipos dos argumentos que a função recebe:" 23 | ] 24 | }, 25 | { 26 | "cell_type": "code", 27 | "execution_count": null, 28 | "metadata": {}, 29 | "outputs": [], 30 | "source": [ 31 | "f(x) = x^2" 32 | ] 33 | }, 34 | { 35 | "cell_type": "markdown", 36 | "metadata": {}, 37 | "source": [ 38 | "e então Julia determina sozinha que tipos de argumentos fazem sentido ou não:" 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": null, 44 | "metadata": {}, 45 | "outputs": [], 46 | "source": [ 47 | "f(10)" 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": null, 53 | "metadata": {}, 54 | "outputs": [], 55 | "source": [ 56 | "f([1, 2, 3])" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "#### Especificando os tipos dos argumentos de entrada\n", 64 | "\n", 65 | "No entanto, também existe a *possibilidade* de informar a Julia que tipos de argumentos são permitidos.\n", 66 | "\n", 67 | "Como exemplo, seja a função `foo` que aceita apenas strings como entrada." 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": null, 73 | "metadata": {}, 74 | "outputs": [], 75 | "source": [ 76 | "foo(x::String, y::String) = println(\"As entradas x e y são ambas strings!\")" 77 | ] 78 | }, 79 | { 80 | "cell_type": "markdown", 81 | "metadata": {}, 82 | "source": [ 83 | "Vemos que para restringir o tipo de `x` e `y` a `String`s, basta usar dois pontos duplo após o nome do argumento seguido de `String`.\n", 84 | "\n", 85 | "Agora, a função `foo` funciona com `String`s mas não com qualquer outro tipo de argumento." 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": null, 91 | "metadata": {}, 92 | "outputs": [], 93 | "source": [ 94 | "foo(\"hello\", \"hi!\")" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": null, 100 | "metadata": {}, 101 | "outputs": [], 102 | "source": [ 103 | "foo(3, 4)" 104 | ] 105 | }, 106 | { 107 | "cell_type": "markdown", 108 | "metadata": {}, 109 | "source": [ 110 | "Parq que `foo` funcione com inteiros (`Int`), vamos colocar `::Int` nos argumentos de entrada quando declaramos `foo`." 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": null, 116 | "metadata": {}, 117 | "outputs": [], 118 | "source": [ 119 | "foo(x::Int, y::Int) = println(\"As entradas x e y são ambas inteiras!\")" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": null, 125 | "metadata": {}, 126 | "outputs": [], 127 | "source": [ 128 | "foo(3, 4)" 129 | ] 130 | }, 131 | { 132 | "cell_type": "markdown", 133 | "metadata": {}, 134 | "source": [ 135 | "Agora `foo` funciona com inteiros! Mas veja, `foo` continua funcionando quando `x` e `y` são strings!" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": null, 141 | "metadata": {}, 142 | "outputs": [], 143 | "source": [ 144 | "foo(\"hello\", \"hi!\")" 145 | ] 146 | }, 147 | { 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "Estamos chegando ao coração do despacho múltiplo. Quando declaramos \n", 152 | "\n", 153 | "```julia\n", 154 | "foo(x::Int, y::Int) = println(\"As entradas x e y são ambas inteiras!\")\n", 155 | "```\n", 156 | "não sobreescrevemos \n", 157 | "```julia\n", 158 | "foo(y::String, y::String)```\n", 159 | "\n", 160 | "O que fizemos foi adicionar um novo ***método*** à ***função genérica*** chamada `foo`.\n", 161 | "\n", 162 | "Uma ***função genérica*** é o conceito abstrato associado com uma operação específica.\n", 163 | "\n", 164 | "Como exemplo, a função genérica `+` representa o conceito de adição.\n", 165 | "\n", 166 | "Um ***método*** é a implementação específica de uma função genérica para *tipos específicos de argumentos*.\n", 167 | "\n", 168 | "Por exemplo, `+` tem métodos que aceitam números de ponto flutuante, inteiros, matrizes, etc\n", 169 | "\n", 170 | "Podemos usar a função `methods` para ver quais os métodos disponíveis para a função genérica `foo`." 171 | ] 172 | }, 173 | { 174 | "cell_type": "code", 175 | "execution_count": null, 176 | "metadata": {}, 177 | "outputs": [], 178 | "source": [ 179 | "methods(foo)" 180 | ] 181 | }, 182 | { 183 | "cell_type": "markdown", 184 | "metadata": {}, 185 | "source": [ 186 | "Curiosidade: quantos métodos você acha que existem para a adição?" 187 | ] 188 | }, 189 | { 190 | "cell_type": "code", 191 | "execution_count": null, 192 | "metadata": {}, 193 | "outputs": [], 194 | "source": [ 195 | "methods(+)" 196 | ] 197 | }, 198 | { 199 | "cell_type": "markdown", 200 | "metadata": {}, 201 | "source": [ 202 | "Então, agora podemos chamar `foo` com inteiros e trings. Quando você chama `foo` com um conjunto particular de argumentos, Julia vai inferir os tipos das entradas e despachar o método específico apropriado. *Isto* é despacho múltiplo.\n", 203 | "\n", 204 | "Despacho múltiplo torna o nosso código genérico e rápido. Nosso código pode ser genérico e flexível porque podemos escrever código em termos de operações abstratas como adição e multiplicação ao invés de implementações específicas. Ao mesmo tempo, o código é rápido porque Julia pode chamar métodos eficientes para os tipos relevantes.\n", 205 | "\n", 206 | "Para saber qual método específico está sendo despachado quando chamamos uma função genérica, podemos usas a macro `@which`:" 207 | ] 208 | }, 209 | { 210 | "cell_type": "code", 211 | "execution_count": null, 212 | "metadata": {}, 213 | "outputs": [], 214 | "source": [ 215 | "@which foo(3, 4)" 216 | ] 217 | }, 218 | { 219 | "cell_type": "markdown", 220 | "metadata": {}, 221 | "source": [ 222 | "Vejamos o que acontece quando usamos `@which` com o operador de adição!" 223 | ] 224 | }, 225 | { 226 | "cell_type": "code", 227 | "execution_count": null, 228 | "metadata": {}, 229 | "outputs": [], 230 | "source": [ 231 | "@which 3.0 + 3.0" 232 | ] 233 | }, 234 | { 235 | "cell_type": "markdown", 236 | "metadata": {}, 237 | "source": [ 238 | "Podemos continuar adicionando métodos para a nossa função genérica `foo`. Podemos até mesmo adicionar um método que aceita o ***tipo abstrato*** `Number`, que inclui subtipos como `Int`, `Float64` e outros objetos que podemos pensar que sejam como números:" 239 | ] 240 | }, 241 | { 242 | "cell_type": "code", 243 | "execution_count": null, 244 | "metadata": {}, 245 | "outputs": [], 246 | "source": [ 247 | "foo(x::Number, y::Number) = println(\"Minhas entradas x e y são ambas números!\")" 248 | ] 249 | }, 250 | { 251 | "cell_type": "markdown", 252 | "metadata": {}, 253 | "source": [ 254 | "Este método de `foo` funciona, por exemplo, com números de ponto flutuante:" 255 | ] 256 | }, 257 | { 258 | "cell_type": "code", 259 | "execution_count": null, 260 | "metadata": {}, 261 | "outputs": [], 262 | "source": [ 263 | "foo(3.0, 4.0)" 264 | ] 265 | }, 266 | { 267 | "cell_type": "markdown", 268 | "metadata": {}, 269 | "source": [ 270 | "Podemos criar um \"último recurso\", um método que usa \"duck-typing\" que aceita qualquer outro tipo de argumento:" 271 | ] 272 | }, 273 | { 274 | "cell_type": "code", 275 | "execution_count": null, 276 | "metadata": {}, 277 | "outputs": [], 278 | "source": [ 279 | "foo(x, y) = println(\"I accept inputs of any type!\")" 280 | ] 281 | }, 282 | { 283 | "cell_type": "markdown", 284 | "metadata": {}, 285 | "source": [ 286 | "Com os métodos já definidos para `foo`, este método será chamado quando passamos argumentos não numéricos a `foo`:" 287 | ] 288 | }, 289 | { 290 | "cell_type": "code", 291 | "execution_count": null, 292 | "metadata": {}, 293 | "outputs": [], 294 | "source": [ 295 | "v = rand(3)\n", 296 | "foo(v, v)" 297 | ] 298 | }, 299 | { 300 | "cell_type": "markdown", 301 | "metadata": { 302 | "collapsed": true 303 | }, 304 | "source": [ 305 | "### Exercícios\n", 306 | "\n", 307 | "#### 9.1\n", 308 | "\n", 309 | "Extenda a função `foo`, adicionando um método que aceita exatamente um único argumento que tem tipo `Bool` e imprime \"foo com um booleano!\"" 310 | ] 311 | }, 312 | { 313 | "cell_type": "code", 314 | "execution_count": null, 315 | "metadata": {}, 316 | "outputs": [], 317 | "source": [] 318 | }, 319 | { 320 | "cell_type": "markdown", 321 | "metadata": {}, 322 | "source": [ 323 | "#### 9.2\n", 324 | "\n", 325 | "Verifique que o método sendo despachado quando você executa\n", 326 | "```julia\n", 327 | "foo(true)\n", 328 | "```\n", 329 | "é o método que você escreveu." 330 | ] 331 | }, 332 | { 333 | "cell_type": "code", 334 | "execution_count": null, 335 | "metadata": {}, 336 | "outputs": [], 337 | "source": [] 338 | } 339 | ], 340 | "metadata": { 341 | "anaconda-cloud": {}, 342 | "kernelspec": { 343 | "display_name": "Julia 1.1.0", 344 | "language": "julia", 345 | "name": "julia-1.1" 346 | }, 347 | "language": "Julia", 348 | "language_info": { 349 | "file_extension": ".jl", 350 | "mimetype": "application/julia", 351 | "name": "julia", 352 | "version": "1.0.0" 353 | }, 354 | "toc": { 355 | "nav_menu": { 356 | "height": "119px", 357 | "width": "251px" 358 | }, 359 | "navigate_menu": true, 360 | "number_sections": true, 361 | "sideBar": true, 362 | "threshold": "2", 363 | "toc_cell": false, 364 | "toc_section_display": "block", 365 | "toc_window_display": false 366 | } 367 | }, 368 | "nbformat": 4, 369 | "nbformat_minor": 1 370 | } 371 | -------------------------------------------------------------------------------- /pt/11.Algebra_linear_basica.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Álgebra linear básica em Julia\n", 8 | "Autor: Andreas Noack Jensen (MIT) (http://www.econ.ku.dk/phdstudent/noack/)\n", 9 | "(com edição de Jane Herriman e tradução de Paulo Jabardo)" 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "Vamos definir uma matriz aleatória" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "A = rand(1:4,3,3)" 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "Definindo um vetor preenchido com um" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": null, 38 | "metadata": {}, 39 | "outputs": [], 40 | "source": [ 41 | "x = fill(1.0, (3,)) # = fill(1.0, 3)" 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "Note que $A$ tem tipo Array{Int64,2} mas $x$ tem tipo Array{Float64,1}. Julia define os _aliases_ (apelidos) Vector{Type}=Array{Type,1} and Matrix{Type}=Array{Type,2}. \n", 49 | "\n", 50 | "Boa parte das operações básicas são iguais em outras linguagens\n", 51 | "\n", 52 | "#### Multiplicação" 53 | ] 54 | }, 55 | { 56 | "cell_type": "code", 57 | "execution_count": null, 58 | "metadata": {}, 59 | "outputs": [], 60 | "source": [ 61 | "b = A*x" 62 | ] 63 | }, 64 | { 65 | "cell_type": "markdown", 66 | "metadata": {}, 67 | "source": [ 68 | "#### Transposição\n", 69 | "Como em outras linguagens, `A'` é o transposto conjugado ou adjunto" 70 | ] 71 | }, 72 | { 73 | "cell_type": "code", 74 | "execution_count": null, 75 | "metadata": {}, 76 | "outputs": [], 77 | "source": [ 78 | "A'" 79 | ] 80 | }, 81 | { 82 | "cell_type": "markdown", 83 | "metadata": {}, 84 | "source": [ 85 | "A transposta da matriz pode ser obtida com " 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": null, 91 | "metadata": {}, 92 | "outputs": [], 93 | "source": [ 94 | "transpose(A)" 95 | ] 96 | }, 97 | { 98 | "cell_type": "markdown", 99 | "metadata": {}, 100 | "source": [ 101 | "#### Multiplicação transposta\n", 102 | "Julia permite escrever isso sem *" 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": null, 108 | "metadata": {}, 109 | "outputs": [], 110 | "source": [ 111 | "A'A" 112 | ] 113 | }, 114 | { 115 | "cell_type": "markdown", 116 | "metadata": {}, 117 | "source": [ 118 | "#### Resolvendo sistemas lineares\n", 119 | "O problema $Ax=b$ para $A$ ***quadrada*** $A$ é resolvida pela função `\\`." 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": null, 125 | "metadata": {}, 126 | "outputs": [], 127 | "source": [ 128 | "A\\b" 129 | ] 130 | }, 131 | { 132 | "cell_type": "markdown", 133 | "metadata": {}, 134 | "source": [ 135 | "`A\\b` fornece a *solução de mínimos quadrados* se tivermos um sistema linear sobredeterminado (a matriz é \"alta\")" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": null, 141 | "metadata": {}, 142 | "outputs": [], 143 | "source": [ 144 | "Atall = rand(3, 2)" 145 | ] 146 | }, 147 | { 148 | "cell_type": "code", 149 | "execution_count": null, 150 | "metadata": {}, 151 | "outputs": [], 152 | "source": [ 153 | "Atall\\b" 154 | ] 155 | }, 156 | { 157 | "cell_type": "markdown", 158 | "metadata": {}, 159 | "source": [ 160 | "e a *solução de mínimos quadrados com norma mínima* se tivermos um problema de mínimos quadrados de posto insuficiente" 161 | ] 162 | }, 163 | { 164 | "cell_type": "code", 165 | "execution_count": null, 166 | "metadata": {}, 167 | "outputs": [], 168 | "source": [ 169 | "v = rand(3)\n", 170 | "rankdef = hcat(v, v)" 171 | ] 172 | }, 173 | { 174 | "cell_type": "code", 175 | "execution_count": null, 176 | "metadata": {}, 177 | "outputs": [], 178 | "source": [ 179 | "rankdef\\b" 180 | ] 181 | }, 182 | { 183 | "cell_type": "markdown", 184 | "metadata": {}, 185 | "source": [ 186 | "Julia também fornece a solução com norma mínima quando temos um problema subdeterminado (uma matriz \"baixa\")" 187 | ] 188 | }, 189 | { 190 | "cell_type": "code", 191 | "execution_count": null, 192 | "metadata": {}, 193 | "outputs": [], 194 | "source": [ 195 | "bshort = rand(2)\n", 196 | "Ashort = rand(2, 3)" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": null, 202 | "metadata": {}, 203 | "outputs": [], 204 | "source": [ 205 | "Ashort\\bshort" 206 | ] 207 | }, 208 | { 209 | "cell_type": "markdown", 210 | "metadata": {}, 211 | "source": [ 212 | "# A biblioteca LinearAlgebra\n", 213 | "\n", 214 | "Mesmo que muitos aspectos de álgebra linear esteja disponível imediatamente (como mostrado acima), existe uma biblioteca padrão chamada de `LinearAlgebra` que trás muitas outras coisas relevantes. Em particular, fornece fatorizações de algumas estruturas de matrizes. Como todos os pacotes, para carreg-a-lo, basta usar `using LinearAlgebra`." 215 | ] 216 | }, 217 | { 218 | "cell_type": "markdown", 219 | "metadata": {}, 220 | "source": [ 221 | "### Exercícios\n", 222 | "\n", 223 | "#### 10.1 \n", 224 | "Calcule o produto interno (ou produto escalar, \"dot\" product) de um vetor com ele mesmo." 225 | ] 226 | }, 227 | { 228 | "cell_type": "code", 229 | "execution_count": null, 230 | "metadata": {}, 231 | "outputs": [], 232 | "source": [] 233 | }, 234 | { 235 | "cell_type": "markdown", 236 | "metadata": {}, 237 | "source": [ 238 | "#### 10.2 \n", 239 | "Cálcule o produto externo de um vetor com ele mesmo." 240 | ] 241 | }, 242 | { 243 | "cell_type": "code", 244 | "execution_count": null, 245 | "metadata": {}, 246 | "outputs": [], 247 | "source": [] 248 | } 249 | ], 250 | "metadata": { 251 | "kernelspec": { 252 | "display_name": "Julia 1.1.0", 253 | "language": "julia", 254 | "name": "julia-1.1" 255 | }, 256 | "language": "Julia", 257 | "language_info": { 258 | "file_extension": ".jl", 259 | "mimetype": "application/julia", 260 | "name": "julia", 261 | "version": "1.0.0" 262 | } 263 | }, 264 | "nbformat": 4, 265 | "nbformat_minor": 1 266 | } 267 | -------------------------------------------------------------------------------- /pt/12.Fatorizacoes_e_outras_brincadeiras.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Fatorações e outras brincadeiras\n", 8 | "Baseado no trabalho de Andreas Noack\n", 9 | "\n", 10 | "## Resumo\n", 11 | " - Fatorações\n", 12 | " - Matrizes com estruturas especiais\n", 13 | " - Álgebra linear genérica" 14 | ] 15 | }, 16 | { 17 | "cell_type": "markdown", 18 | "metadata": {}, 19 | "source": [ 20 | "Antes de começar, vamos criar um sistema linear e usar `LinearAlgebra` para carregar as fatorizações and matrizes com estrutura special." 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": null, 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "using LinearAlgebra\n", 30 | "A = rand(3, 3)\n", 31 | "x = fill(1, (3,))\n", 32 | "b = A * x" 33 | ] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "metadata": {}, 38 | "source": [ 39 | "## Fatorações\n", 40 | "\n", 41 | "#### Fatoração ou decomposição LU \n", 42 | "Em Julia podemos fazer a decomposição LU \n", 43 | "```julia\n", 44 | "PA = LU\n", 45 | "``` \n", 46 | "onde `P` é a matriz de permutação, `L` é a matriz triangular inferior com diagonal unitária e `U` é a matriz superior triangular, usando `lufact`.\n", 47 | "\n", 48 | "Julia permite o cálculo da decomposição LU e define um tipo de decomposição para armazená-la." 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": null, 54 | "metadata": {}, 55 | "outputs": [], 56 | "source": [ 57 | "Alu = lu(A)" 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": null, 63 | "metadata": {}, 64 | "outputs": [], 65 | "source": [ 66 | "typeof(Alu)" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "metadata": {}, 72 | "source": [ 73 | "As diferentes partes da fatoração podem ser obtidas acessando suas propriedades especiais" 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": null, 79 | "metadata": {}, 80 | "outputs": [], 81 | "source": [ 82 | "Alu.P" 83 | ] 84 | }, 85 | { 86 | "cell_type": "code", 87 | "execution_count": null, 88 | "metadata": {}, 89 | "outputs": [], 90 | "source": [ 91 | "Alu.L" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": null, 97 | "metadata": {}, 98 | "outputs": [], 99 | "source": [ 100 | "Alu.U" 101 | ] 102 | }, 103 | { 104 | "cell_type": "markdown", 105 | "metadata": {}, 106 | "source": [ 107 | "Julia pode despachar métodos em objetos de fatoração.\n", 108 | "\n", 109 | "Como exemplo, podemos resolver sistemas lineares utilizando a matriz original ou o objeto de fatoração." 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": null, 115 | "metadata": {}, 116 | "outputs": [], 117 | "source": [ 118 | "A\\b" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": null, 124 | "metadata": {}, 125 | "outputs": [], 126 | "source": [ 127 | "Alu\\b" 128 | ] 129 | }, 130 | { 131 | "cell_type": "markdown", 132 | "metadata": {}, 133 | "source": [ 134 | "De maneira análoga, podemos calcular a determinante de `A` usando `A` ou o objeto de fatoração" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": null, 140 | "metadata": {}, 141 | "outputs": [], 142 | "source": [ 143 | "det(A) ≈ det(Alu)" 144 | ] 145 | }, 146 | { 147 | "cell_type": "markdown", 148 | "metadata": {}, 149 | "source": [ 150 | "#### Fatoração QR\n", 151 | "\n", 152 | "Em Julia podemos realizar a decomposição QR\n", 153 | "```\n", 154 | "A=QR\n", 155 | "``` \n", 156 | "\n", 157 | "onde `Q` é unitária/ortogonal e `R` é uma matriz triangular superior, usando `qrfact`. " 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": null, 163 | "metadata": {}, 164 | "outputs": [], 165 | "source": [ 166 | "Aqr = qr(A)" 167 | ] 168 | }, 169 | { 170 | "cell_type": "markdown", 171 | "metadata": {}, 172 | "source": [ 173 | "Igualmente à decomposição LU, as matrizes `Q` e `R` podem ser extraídas da decomposição QR via" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": null, 179 | "metadata": {}, 180 | "outputs": [], 181 | "source": [ 182 | "Aqr.Q" 183 | ] 184 | }, 185 | { 186 | "cell_type": "code", 187 | "execution_count": null, 188 | "metadata": {}, 189 | "outputs": [], 190 | "source": [ 191 | "Aqr.R" 192 | ] 193 | }, 194 | { 195 | "cell_type": "markdown", 196 | "metadata": {}, 197 | "source": [ 198 | "#### Decomposição em auto-vetores" 199 | ] 200 | }, 201 | { 202 | "cell_type": "markdown", 203 | "metadata": {}, 204 | "source": [ 205 | "Os resultados de decomposição em auto-vetores, decomposição de valor singular, fatoração de Hessemberg e decomposição de Schur são armazenados nos tipos `Factorization`.\n", 206 | "\n", 207 | "A decomposição em auto-vetores pode ser calculada " 208 | ] 209 | }, 210 | { 211 | "cell_type": "code", 212 | "execution_count": null, 213 | "metadata": {}, 214 | "outputs": [], 215 | "source": [ 216 | "Asym = A + A'\n", 217 | "AsymEig = eigen(Asym)" 218 | ] 219 | }, 220 | { 221 | "cell_type": "markdown", 222 | "metadata": {}, 223 | "source": [ 224 | "Os valores e os vetores podem ser extraídos utilizando indexação especial" 225 | ] 226 | }, 227 | { 228 | "cell_type": "code", 229 | "execution_count": null, 230 | "metadata": {}, 231 | "outputs": [], 232 | "source": [ 233 | "AsymEig.values" 234 | ] 235 | }, 236 | { 237 | "cell_type": "code", 238 | "execution_count": null, 239 | "metadata": {}, 240 | "outputs": [], 241 | "source": [ 242 | "AsymEig.vectors" 243 | ] 244 | }, 245 | { 246 | "cell_type": "markdown", 247 | "metadata": {}, 248 | "source": [ 249 | "Novamente, quando a fatoração é armazenada em um tipo específico, podemos despachar neste tipo e escrever métodos especializados que exploram as propriedades da fatoração, isto é, que $A^{-1}=(V\\Lambda V^{-1})^{-1}=V\\Lambda^{-1}V^{-1}$." 250 | ] 251 | }, 252 | { 253 | "cell_type": "code", 254 | "execution_count": null, 255 | "metadata": {}, 256 | "outputs": [], 257 | "source": [ 258 | "inv(AsymEig)*Asym" 259 | ] 260 | }, 261 | { 262 | "cell_type": "markdown", 263 | "metadata": {}, 264 | "source": [ 265 | "## Matrizes com estrutura especial\n", 266 | "A estrutura de uma matriz é muito importante em álgebra linear. Para ver o *quão* importante é, vamos trabalhar com um sistema linear grande" 267 | ] 268 | }, 269 | { 270 | "cell_type": "code", 271 | "execution_count": null, 272 | "metadata": {}, 273 | "outputs": [], 274 | "source": [ 275 | "n = 1000\n", 276 | "A = randn(n,n);" 277 | ] 278 | }, 279 | { 280 | "cell_type": "markdown", 281 | "metadata": {}, 282 | "source": [ 283 | "Julia pode algumas vezes inferir a estrutura da matriz especial" 284 | ] 285 | }, 286 | { 287 | "cell_type": "code", 288 | "execution_count": null, 289 | "metadata": {}, 290 | "outputs": [], 291 | "source": [ 292 | "Asym = A + A'\n", 293 | "issymmetric(Asym)" 294 | ] 295 | }, 296 | { 297 | "cell_type": "markdown", 298 | "metadata": {}, 299 | "source": [ 300 | "mas algumas vezes erros de ponto flutuante podem atrapalhar de maneira considerável." 301 | ] 302 | }, 303 | { 304 | "cell_type": "code", 305 | "execution_count": null, 306 | "metadata": {}, 307 | "outputs": [], 308 | "source": [ 309 | "Asym_noisy = copy(Asym)\n", 310 | "Asym_noisy[1,2] += 5eps()" 311 | ] 312 | }, 313 | { 314 | "cell_type": "code", 315 | "execution_count": null, 316 | "metadata": {}, 317 | "outputs": [], 318 | "source": [ 319 | "issymmetric(Asym_noisy)" 320 | ] 321 | }, 322 | { 323 | "cell_type": "markdown", 324 | "metadata": {}, 325 | "source": [ 326 | "Por sorte, podemos declarar explicitamente a estrutura da matriz, como por exemplo, `Diagonal`, `Triangular`, `Symmetric`, `Hermitian`, `Tridiagonal` e `SymTridiagonal`." 327 | ] 328 | }, 329 | { 330 | "cell_type": "code", 331 | "execution_count": null, 332 | "metadata": {}, 333 | "outputs": [], 334 | "source": [ 335 | "Asym_explicit = Symmetric(Asym_noisy);" 336 | ] 337 | }, 338 | { 339 | "cell_type": "markdown", 340 | "metadata": {}, 341 | "source": [ 342 | "Vamos comparar o tempo que leva para Julia calcular os auto-valores de `Asym`, `Asym_noisy`, e `Asym_explicit`" 343 | ] 344 | }, 345 | { 346 | "cell_type": "code", 347 | "execution_count": null, 348 | "metadata": {}, 349 | "outputs": [], 350 | "source": [ 351 | "@time eigvals(Asym);" 352 | ] 353 | }, 354 | { 355 | "cell_type": "code", 356 | "execution_count": null, 357 | "metadata": {}, 358 | "outputs": [], 359 | "source": [ 360 | "@time eigvals(Asym_noisy);" 361 | ] 362 | }, 363 | { 364 | "cell_type": "code", 365 | "execution_count": null, 366 | "metadata": {}, 367 | "outputs": [], 368 | "source": [ 369 | "@time eigvals(Asym_explicit);" 370 | ] 371 | }, 372 | { 373 | "cell_type": "markdown", 374 | "metadata": {}, 375 | "source": [ 376 | "Neste example, usando `Symmetric()` em `Asym_noisy` fez os nossos cálculos aproximadamente about `5x` mais efficiente :)" 377 | ] 378 | }, 379 | { 380 | "cell_type": "markdown", 381 | "metadata": {}, 382 | "source": [ 383 | "#### Um problema grande\n", 384 | "Usando os tipos `Tridiagonal` e `SymTridiagonal` types para armazenar matrizes tridiagonais é possível trabalhar com problemas tridiagonais enormes. O exemplo a seguir não seria possível neste laptop se a matriz fosse armazenada como uma matriz densa de tipo `Matrix`." 385 | ] 386 | }, 387 | { 388 | "cell_type": "code", 389 | "execution_count": null, 390 | "metadata": {}, 391 | "outputs": [], 392 | "source": [ 393 | "n = 1_000_000;\n", 394 | "A = SymTridiagonal(randn(n), randn(n-1));\n", 395 | "@time eigmax(A)" 396 | ] 397 | }, 398 | { 399 | "cell_type": "markdown", 400 | "metadata": {}, 401 | "source": [ 402 | "## Álgebra linear genérica\n", 403 | "O jeito usual de adicionar suporte a álgebra linear numérica é fazer uma interface às funções disponíveis nas bibliotecas BLAS e LAPACK. Para matrizes como elementos com tipos `Float32`, `Float64`, `Complex{Float32}` ou `Complex{Float64}` é exatamente isso que Julia faz (assim como numpy/python, matlab, R, etc).\n", 404 | "\n", 405 | "No entanto, Julia também implementa álgebra linear genérica, permitindo que você trabalhe com matrizes de outros tipos como racionais por exemplo." 406 | ] 407 | }, 408 | { 409 | "cell_type": "markdown", 410 | "metadata": {}, 411 | "source": [ 412 | "#### Números racionais\n", 413 | "Julia já vem com números racionais. Para construir números racionais, use a barra pra frente dupla:" 414 | ] 415 | }, 416 | { 417 | "cell_type": "code", 418 | "execution_count": null, 419 | "metadata": {}, 420 | "outputs": [], 421 | "source": [ 422 | "1//2" 423 | ] 424 | }, 425 | { 426 | "cell_type": "markdown", 427 | "metadata": {}, 428 | "source": [ 429 | "#### Exemplo: Sistema de equações linear racional\n", 430 | "O exemplo a seguir mostra como um sistema de equações lineares com elementos racionais pode ser resolvido sem utilizar ponto flutuante. Cuidado que à medida que estas matrizes crescem, estouro (_overflow_) é um problema comum e eventualmente Inteiros grandes (`BigInt`) são necessários." 431 | ] 432 | }, 433 | { 434 | "cell_type": "code", 435 | "execution_count": null, 436 | "metadata": {}, 437 | "outputs": [], 438 | "source": [ 439 | "Arational = Matrix{Rational{BigInt}}(rand(1:10, 3, 3))/10" 440 | ] 441 | }, 442 | { 443 | "cell_type": "code", 444 | "execution_count": null, 445 | "metadata": {}, 446 | "outputs": [], 447 | "source": [ 448 | "x = fill(1, 3)\n", 449 | "b = Arational*x" 450 | ] 451 | }, 452 | { 453 | "cell_type": "code", 454 | "execution_count": null, 455 | "metadata": {}, 456 | "outputs": [], 457 | "source": [ 458 | "Arational\\b" 459 | ] 460 | }, 461 | { 462 | "cell_type": "code", 463 | "execution_count": null, 464 | "metadata": {}, 465 | "outputs": [], 466 | "source": [ 467 | "lu(Arational)" 468 | ] 469 | }, 470 | { 471 | "cell_type": "markdown", 472 | "metadata": {}, 473 | "source": [ 474 | "### Exercícios\n", 475 | "\n", 476 | "#### 11.1\n", 477 | "Quais são os auto-valores da matriz A?\n", 478 | "\n", 479 | "```\n", 480 | "A =\n", 481 | "[\n", 482 | " 140 97 74 168 131\n", 483 | " 97 106 89 131 36\n", 484 | " 74 89 152 144 71\n", 485 | " 168 131 144 54 142\n", 486 | " 131 36 71 142 36\n", 487 | "]\n", 488 | "```" 489 | ] 490 | }, 491 | { 492 | "cell_type": "code", 493 | "execution_count": null, 494 | "metadata": {}, 495 | "outputs": [], 496 | "source": [] 497 | }, 498 | { 499 | "cell_type": "markdown", 500 | "metadata": {}, 501 | "source": [ 502 | "#### 11.2 \n", 503 | "Create a `Diagonal` matrix from the eigenvalues of `A`." 504 | ] 505 | }, 506 | { 507 | "cell_type": "code", 508 | "execution_count": null, 509 | "metadata": {}, 510 | "outputs": [], 511 | "source": [] 512 | }, 513 | { 514 | "cell_type": "markdown", 515 | "metadata": {}, 516 | "source": [ 517 | "#### 11.3 \n", 518 | "Create a `LowerTriangular` matrix from `A`." 519 | ] 520 | }, 521 | { 522 | "cell_type": "code", 523 | "execution_count": null, 524 | "metadata": {}, 525 | "outputs": [], 526 | "source": [] 527 | }, 528 | { 529 | "cell_type": "markdown", 530 | "metadata": {}, 531 | "source": [ 532 | "### Please let us know how we're doing!\n", 533 | "https://tinyurl.com/introJuliaFeedback" 534 | ] 535 | }, 536 | { 537 | "cell_type": "code", 538 | "execution_count": null, 539 | "metadata": {}, 540 | "outputs": [], 541 | "source": [] 542 | } 543 | ], 544 | "metadata": { 545 | "kernelspec": { 546 | "display_name": "Julia 1.1.0", 547 | "language": "julia", 548 | "name": "julia-1.1" 549 | }, 550 | "language": "Julia", 551 | "language_info": { 552 | "file_extension": ".jl", 553 | "mimetype": "application/julia", 554 | "name": "julia", 555 | "version": "1.0.0" 556 | } 557 | }, 558 | "nbformat": 4, 559 | "nbformat_minor": 1 560 | } 561 | --------------------------------------------------------------------------------